text,length,is_long_context,metric_val,label_metric
"/*
 *  Copyright 2019-2021 Diligent Graphics LLC
 *  Copyright 2015-2019 Egor Yusov
 *  
 *  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.
 *
 *  In no event and under no legal theory, whether in tort (including negligence), 
 *  contract, or otherwise, unless required by applicable law (such as deliberate 
 *  and grossly negligent acts) or agreed to in writing, shall any Contributor be
 *  liable for any damages, including any direct, indirect, special, incidental, 
 *  or consequential damages of any character arising as a result of this License or 
 *  out of the use or inability to use the software (including but not limited to damages 
 *  for loss of goodwill, work stoppage, computer failure or malfunction, or any and 
 *  all other commercial damages or losses), even if such Contributor has been advised 
 *  of the possibility of such damages.
 */

#include <array>
#include <limits>

#include ""TestingEnvironment.hpp""
#include ""GraphicsAccessories.hpp""

#include ""gtest/gtest.h""

using namespace Diligent;
using namespace Diligent::Testing;

namespace
{

static constexpr char g_TrivialVSSource[] = R""(
void main(out float4 pos : SV_Position)
{
    pos = float4(0.0, 0.0, 0.0, 0.0);
}
)"";

static constexpr char g_TrivialPSSource[] = R""(
float4 main() : SV_Target
{
    return float4(0.0, 0.0, 0.0, 0.0);
}
)"";

static constexpr char g_TexturePSSource[] = R""(
Texture2D g_Texture;
float4 main() : SV_Target
{
    return g_Texture.Load(int3(0,0,0));
}
)"";

static constexpr char g_TrivialMSSource[] = R""(
struct VertexOut
{
    float4 Pos : SV_Position;
};

[numthreads(1,1,1)]
[outputtopology(""triangle"")]
void main(out indices  uint3     tris[1],
          out vertices VertexOut verts[3])
{
    SetMeshOutputCounts(4, 2);

    tris[0] = uint3(0, 1, 2);
    verts[0].Pos = float4(0.0, 0.0, 0.0, 1.0);
    verts[1].Pos = float4(-1.0, 1.0, 0.0, 1.0);
    verts[2].Pos = float4(1.0, 1.0, 0.0, 1.0);
}
)"";

static constexpr char g_TrivialCSSource[] = R""(
[numthreads(8,8,1)]
void main()
{
}
)"";

static constexpr char g_TrivialRGenSource[] = R""(
[shader(""raygeneration"")]
void main()
{}
)"";

static constexpr char g_TrivialRMissSource[] = R""(
struct RTPayload { float4 Color; };
[shader(""miss"")]
void main(inout RTPayload payload)
{}
)"";

static constexpr char g_TrivialRCHitSource[] = R""(
struct RTPayload { float4 Color; };
[shader(""closesthit"")]
void main(inout RTPayload payload, in BuiltInTriangleIntersectionAttributes attr)
{}
)"";

static constexpr char g_TrivialRAHitSource[] = R""(
struct RTPayload { float4 Color; };
[shader(""anyhit"")]
void main(inout RTPayload payload, in BuiltInTriangleIntersectionAttributes attr)
{}
)"";

static constexpr char g_TrivialRIntSource[] = R""(
[shader(""intersection"")]
void main()
{}
)"";

static constexpr char g_TrivialRCallSource[] = R""(
struct Params { float4 Col; };
[shader(""callable"")]
void main(inout Params params)
{}
)"";


class PSOCreationFailureTest : public ::testing::Test
{
protected:
    static void SetUpTestSuite()
    {
        auto* const pEnv       = TestingEnvironment::GetInstance();
        auto* const pDevice    = pEnv->GetDevice();
        const auto& deviceCaps = pDevice->GetDeviceCaps();

        sm_HasMeshShader = deviceCaps.Features.MeshShaders && pEnv->HasDXCompiler();
        sm_HasRayTracing = pEnv->SupportsRayTracing();

        ShaderCreateInfo ShaderCI;
        ShaderCI.Source                     = g_TrivialVSSource;
        ShaderCI.EntryPoint                 = ""main"";
        ShaderCI.Desc.ShaderType            = SHADER_TYPE_VERTEX;
        ShaderCI.Desc.Name                  = ""TrivialVS (PSOCreationFailureTest)"";
        ShaderCI.SourceLanguage             = SHADER_SOURCE_LANGUAGE_HLSL;
        ShaderCI.ShaderCompiler             = pEnv->GetDefaultCompiler(ShaderCI.SourceLanguage);
        ShaderCI.UseCombinedTextureSamplers = true;
        pDevice->CreateShader(ShaderCI, &sm_pTrivialVS);
        ASSERT_TRUE(sm_pTrivialVS);

        ShaderCI.Source          = g_TrivialPSSource;
        ShaderCI.Desc.ShaderType = SHADER_TYPE_PIXEL;
        ShaderCI.Desc.Name       = ""TrivialPS (PSOCreationFailureTest)"";
        pDevice->CreateShader(ShaderCI, &sm_pTrivialPS);
        ASSERT_TRUE(sm_pTrivialPS);

        ShaderCI.Source          = g_TexturePSSource;
        ShaderCI.Desc.ShaderType = SHADER_TYPE_PIXEL;
        ShaderCI.Desc.Name       = ""TexturePS (PSOCreationFailureTest)"";
        pDevice->CreateShader(ShaderCI, &sm_pTexturePS);
        ASSERT_TRUE(sm_pTexturePS);

        ShaderCI.Source          = g_TrivialCSSource;
        ShaderCI.Desc.ShaderType = SHADER_TYPE_COMPUTE;
        ShaderCI.Desc.Name       = ""TrivialCS (PSOCreationFailureTest)"";
        pDevice->CreateShader(ShaderCI, &sm_pTrivialCS);
        ASSERT_TRUE(sm_pTrivialCS);

        sm_DefaultGraphicsPsoCI.PSODesc.Name                      = ""PSOCreationFailureTest - default graphics PSO desc"";
        sm_DefaultGraphicsPsoCI.GraphicsPipeline.NumRenderTargets = 1;
        sm_DefaultGraphicsPsoCI.GraphicsPipeline.RTVFormats[0]    = TEX_FORMAT_RGBA8_UNORM;
        sm_DefaultGraphicsPsoCI.GraphicsPipeline.DSVFormat        = TEX_FORMAT_D32_FLOAT;

        sm_DefaultGraphicsPsoCI.pVS = sm_pTrivialVS;
        sm_DefaultGraphicsPsoCI.pPS = sm_pTrivialPS;

        {
            RefCntAutoPtr<IPipelineState> pGraphicsPSO;
            pDevice->CreateGraphicsPipelineState(GetGraphicsPSOCreateInfo(""PSOCreationFailureTest - OK graphics PSO""), &pGraphicsPSO);
            ASSERT_TRUE(pGraphicsPSO);
        }

        sm_DefaultComputePsoCI.PSODesc.Name = ""PSOCreationFailureTest - default compute PSO desc"";
        sm_DefaultComputePsoCI.pCS          = sm_pTrivialCS;

        {
            RefCntAutoPtr<IPipelineState> pComputePSO;
            pDevice->CreateComputePipelineState(GetComputePSOCreateInfo(""PSOCreationFailureTest - OK compute PSO""), &pComputePSO);
            ASSERT_TRUE(pComputePSO);
        }

        if (sm_HasMeshShader)
        {
            ShaderCI.ShaderCompiler = SHADER_COMPILER_DXC;

            ShaderCI.Source          = g_TrivialMSSource;
            ShaderCI.Desc.ShaderType = SHADER_TYPE_MESH;
            ShaderCI.Desc.Name       = ""TrivialMS DXC (PSOCreationFailureTest)"";
            pDevice->CreateShader(ShaderCI, &sm_pTrivialMS);
            ASSERT_TRUE(sm_pTrivialMS);

            ShaderCI.Source          = g_TrivialPSSource;
            ShaderCI.Desc.ShaderType = SHADER_TYPE_PIXEL;
            ShaderCI.Desc.Name       = ""TrivialPS DXC (PSOCreationFailureTest)"";
            pDevice->CreateShader(ShaderCI, &sm_pTrivialPS_DXC);
            ASSERT_TRUE(sm_pTrivialPS_DXC);

            sm_DefaultMeshPsoCI.PSODesc.Name                      = ""PSOCreationFailureTest - default mesh PSO desc"";
            sm_DefaultMeshPsoCI.GraphicsPipeline.NumRenderTargets = 1;
            sm_DefaultMeshPsoCI.GraphicsPipeline.RTVFormats[0]    = TEX_FORMAT_RGBA8_UNORM;
            sm_DefaultMeshPsoCI.GraphicsPipeline.DSVFormat        = TEX_FORMAT_D32_FLOAT;
            sm_DefaultMeshPsoCI.PSODesc.PipelineType              = PIPELINE_TYPE_MESH;

            sm_DefaultMeshPsoCI.pMS = sm_pTrivialMS;
            sm_DefaultMeshPsoCI.pPS = sm_pTrivialPS_DXC;

            RefCntAutoPtr<IPipelineState> pMeshPSO;
            pDevice->CreateGraphicsPipelineState(GetMeshPSOCreateInfo(""PSOCreationFailureTest - OK mesh PSO""), &pMeshPSO);
            ASSERT_TRUE(pMeshPSO);
        }

        if (sm_HasRayTracing)
        {
            ShaderCI.ShaderCompiler = SHADER_COMPILER_DXC;

            ShaderCI.Source          = g_TrivialRGenSource;
            ShaderCI.Desc.ShaderType = SHADER_TYPE_RAY_GEN;
            ShaderCI.Desc.Name       = ""TrivialRGen (PSOCreationFailureTest)"";
            pDevice->CreateShader(ShaderCI, &sm_pTrivialRG);
            ASSERT_TRUE(sm_pTrivialRG);

            ShaderCI.Source          = g_TrivialRMissSource;
            ShaderCI.Desc.ShaderType = SHADER_TYPE_RAY_MISS;
            ShaderCI.Desc.Name       = ""TrivialRMiss (PSOCreationFailureTest)"";
            pDevice->CreateShader(ShaderCI, &sm_pTrivialRMiss);
            ASSERT_TRUE(sm_pTrivialRMiss);

            ShaderCI.Source          = g_TrivialRCallSource;
            ShaderCI.Desc.ShaderType = SHADER_TYPE_CALLABLE;
            ShaderCI.Desc.Name       = ""TrivialRCall (PSOCreationFailureTest)"";
            pDevice->CreateShader(ShaderCI, &sm_pTrivialRCall);
            ASSERT_TRUE(sm_pTrivialRCall);

            ShaderCI.Source          = g_TrivialRCHitSource;
            ShaderCI.Desc.ShaderType = SHADER_TYPE_RAY_CLOSEST_HIT;
            ShaderCI.Desc.Name       = ""TrivialRCHit (PSOCreationFailureTest)"";
            pDevice->CreateShader(ShaderCI, &sm_pTrivialRCHit);
            ASSERT_TRUE(sm_pTrivialRCHit);

            ShaderCI.Source          = g_TrivialRAHitSource;
            ShaderCI.Desc.ShaderType = SHADER_TYPE_RAY_ANY_HIT;
            ShaderCI.Desc.Name       = ""TrivialRAHit (PSOCreationFailureTest)"";
            pDevice->CreateShader(ShaderCI, &sm_pTrivialRAHit);
            ASSERT_TRUE(sm_pTrivialRAHit);

            ShaderCI.Source          = g_TrivialRIntSource;
            ShaderCI.Desc.ShaderType = SHADER_TYPE_RAY_INTERSECTION;
            ShaderCI.Desc.Name       = ""TrivialRInt (PSOCreationFailureTest)"";
            pDevice->CreateShader(ShaderCI, &sm_pTrivialRInt);
            ASSERT_TRUE(sm_pTrivialRInt);

            sm_DefaultRayTracingPsoCI.PSODesc.Name         = ""PSOCreationFailureTest - default ray tracing PSO desc"";
            sm_DefaultRayTracingPsoCI.PSODesc.PipelineType = PIPELINE_TYPE_RAY_TRACING;

            sm_DefaultRayTracingPsoCI.RayTracingPipeline.MaxRecursionDepth = 1;

            sm_GeneralGroups[0]                          = {""Main"", sm_pTrivialRG};
            sm_DefaultRayTracingPsoCI.pGeneralShaders    = sm_GeneralGroups.data();
            sm_DefaultRayTracingPsoCI.GeneralShaderCount = static_cast<Uint32>(sm_GeneralGroups.size());

            RefCntAutoPtr<IPipelineState> pRayTracingPSO;
            pDevice->CreateGraphicsPipelineState(GetMeshPSOCreateInfo(""PSOCreationFailureTest - OK ray tracing PSO""), &pRayTracingPSO);
            ASSERT_TRUE(pRayTracingPSO);
        }

        RenderPassDesc RPDesc;
        RPDesc.Name = ""PSOCreationFailureTest - render pass"";
        RenderPassAttachmentDesc Attachments[2]{};
        Attachments[0].Format       = TEX_FORMAT_RGBA8_UNORM;
        Attachments[0].InitialState = RESOURCE_STATE_RENDER_TARGET;
        Attachments[0].FinalState   = RESOURCE_STATE_RENDER_TARGET;
        Attachments[1].Format       = TEX_FORMAT_D32_FLOAT;
        Attachments[1].InitialState = RESOURCE_STATE_DEPTH_WRITE;
        Attachments[1].FinalState   = RESOURCE_STATE_DEPTH_WRITE;
        RPDesc.AttachmentCount      = _countof(Attachments);
        RPDesc.pAttachments         = Attachments;

        AttachmentReference ColorAttachmentRef{0, RESOURCE_STATE_RENDER_TARGET};
        AttachmentReference DepthAttachmentRef{1, RESOURCE_STATE_DEPTH_WRITE};
        SubpassDesc         Subpasses[1]{};
        Subpasses[0].RenderTargetAttachmentCount = 1;
        Subpasses[0].pRenderTargetAttachments    = &ColorAttachmentRef;
        Subpasses[0].pDepthStencilAttachment     = &DepthAttachmentRef;

        RPDesc.SubpassCount = _countof(Subpasses);
        RPDesc.pSubpasses   = Subpasses;

        pDevice->CreateRenderPass(RPDesc, &sm_pRenderPass);
        ASSERT_TRUE(sm_pRenderPass);

        {
            RefCntAutoPtr<IPipelineState> pGraphicsPSO;
            pDevice->CreateGraphicsPipelineState(GetGraphicsPSOCreateInfo(""PSOCreationFailureTest - OK PSO with render pass"", true), &pGraphicsPSO);
            ASSERT_TRUE(pGraphicsPSO);
        }

        {
            PipelineResourceDesc Resources[] = //
                {
                    PipelineResourceDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_Texture"", 1, SHADER_RESOURCE_TYPE_TEXTURE_SRV, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE} //
                };
            ImmutableSamplerDesc ImmutableSmplers[] //
                {
                    ImmutableSamplerDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_Texture_sampler"", SamplerDesc{}} //
                };

            PipelineResourceSignatureDesc PRSDesc;
            PRSDesc.Name                 = ""PRS0"";
            PRSDesc.NumResources         = _countof(Resources);
            PRSDesc.Resources            = Resources;
            PRSDesc.NumImmutableSamplers = _countof(ImmutableSmplers);
            PRSDesc.ImmutableSamplers    = ImmutableSmplers;
            pDevice->CreatePipelineResourceSignature(PRSDesc, &sm_pSignature0);
            ASSERT_TRUE(sm_pSignature0);
        }

        {
            PipelineResourceDesc Resources[] = //
                {
                    PipelineResourceDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_Texture2"", 1, SHADER_RESOURCE_TYPE_TEXTURE_SRV, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE} //
                };
            PipelineResourceSignatureDesc PRSDesc;
            PRSDesc.Name         = ""PRS0A"";
            PRSDesc.NumResources = _countof(Resources);
            PRSDesc.Resources    = Resources;
            pDevice->CreatePipelineResourceSignature(PRSDesc, &sm_pSignature0A);
            ASSERT_TRUE(sm_pSignature0A);
        }

        if (deviceCaps.Features.GeometryShaders)
        {
            PipelineResourceDesc Resources[] = //
                {
                    PipelineResourceDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_GEOMETRY, ""g_Texture"", 1, SHADER_RESOURCE_TYPE_TEXTURE_SRV, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE} //
                };
            PipelineResourceSignatureDesc PRSDesc;
            PRSDesc.Name         = ""PRS1"";
            PRSDesc.BindingIndex = 1;
            PRSDesc.NumResources = _countof(Resources);
            PRSDesc.Resources    = Resources;
            pDevice->CreatePipelineResourceSignature(PRSDesc, &sm_pSignature1);
            ASSERT_TRUE(sm_pSignature1);
        }

        if (deviceCaps.Features.GeometryShaders)
        {
            PipelineResourceDesc Resources[] = //
                {
                    PipelineResourceDesc{SHADER_TYPE_GEOMETRY, ""g_Texture"", 1, SHADER_RESOURCE_TYPE_TEXTURE_SRV, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE} //
                };
            ImmutableSamplerDesc ImmutableSmplers[] //
                {
                    ImmutableSamplerDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_GEOMETRY, ""g_Texture_sampler"", SamplerDesc{}} //
                };

            PipelineResourceSignatureDesc PRSDesc;
            PRSDesc.Name                 = ""PRS1A"";
            PRSDesc.BindingIndex         = 1;
            PRSDesc.NumResources         = _countof(Resources);
            PRSDesc.Resources            = Resources;
            PRSDesc.NumImmutableSamplers = _countof(ImmutableSmplers);
            PRSDesc.ImmutableSamplers    = ImmutableSmplers;
            pDevice->CreatePipelineResourceSignature(PRSDesc, &sm_pSignature1A);
            ASSERT_TRUE(sm_pSignature1A);
        }
    }

    static void TearDownTestSuite()
    {
        sm_pTrivialVS.Release();
        sm_pTrivialPS.Release();
        sm_pTrivialPS_DXC.Release();
        sm_pTexturePS.Release();
        sm_pTrivialMS.Release();
        sm_pTrivialCS.Release();
        sm_pTrivialRG.Release();
        sm_pTrivialRMiss.Release();
        sm_pTrivialRCall.Release();
        sm_pTrivialRCHit.Release();
        sm_pTrivialRAHit.Release();
        sm_pTrivialRInt.Release();
        sm_pRenderPass.Release();
        sm_pSignature0.Release();
        sm_pSignature0A.Release();
        sm_pSignature1.Release();
        sm_pSignature1A.Release();
    }

    static GraphicsPipelineStateCreateInfo GetGraphicsPSOCreateInfo(const char* Name, bool UseRenderPass = false)
    {
        auto CI{sm_DefaultGraphicsPsoCI};
        CI.PSODesc.Name = Name;
        if (UseRenderPass)
        {
            CI.GraphicsPipeline.NumRenderTargets = 0;
            CI.GraphicsPipeline.RTVFormats[0]    = TEX_FORMAT_UNKNOWN;
            CI.GraphicsPipeline.DSVFormat        = TEX_FORMAT_UNKNOWN;
            CI.GraphicsPipeline.pRenderPass      = sm_pRenderPass;
        }
        return CI;
    }

    static GraphicsPipelineStateCreateInfo GetMeshPSOCreateInfo(const char* Name, bool UseRenderPass = false)
    {
        VERIFY_EXPR(HasMeshShader());

        auto CI{sm_DefaultMeshPsoCI};
        CI.PSODesc.Name = Name;
        if (UseRenderPass)
        {
            CI.GraphicsPipeline.NumRenderTargets = 0;
            CI.GraphicsPipeline.RTVFormats[0]    = TEX_FORMAT_UNKNOWN;
            CI.GraphicsPipeline.DSVFormat        = TEX_FORMAT_UNKNOWN;
            CI.GraphicsPipeline.pRenderPass      = sm_pRenderPass;
        }
        return CI;
    }

    static ComputePipelineStateCreateInfo GetComputePSOCreateInfo(const char* Name)
    {
        auto CI{sm_DefaultComputePsoCI};
        CI.PSODesc.Name = Name;
        return CI;
    }

    static RayTracingPipelineStateCreateInfo GetRayTracingPSOCreateInfo(const char* Name)
    {
        VERIFY_EXPR(HasRayTracing());

        auto CI{sm_DefaultRayTracingPsoCI};
        CI.PSODesc.Name = Name;
        return CI;
    }

    static IShader* GetVS() { return sm_pTrivialVS; }
    static IShader* GetPS() { return sm_pTrivialPS; }
    static IShader* GetMS() { return sm_pTrivialMS; }

    static IShader* GetTexturePS() { return sm_pTexturePS; }

    static IShader* GetRayGen() { return sm_pTrivialRG; }
    static IShader* GetRayMiss() { return sm_pTrivialRMiss; }
    static IShader* GetCallable() { return sm_pTrivialRCall; }
    static IShader* GetRayClosestHit() { return sm_pTrivialRCHit; }
    static IShader* GetRayAnyHit() { return sm_pTrivialRAHit; }
    static IShader* GetRayIntersection() { return sm_pTrivialRInt; }

    static bool HasMeshShader() { return sm_HasMeshShader; }
    static bool HasRayTracing() { return sm_HasRayTracing; }

    static void TestCreatePSOFailure(GraphicsPipelineStateCreateInfo CI, const char* ExpectedErrorSubstring)
    {
        auto* const pEnv    = TestingEnvironment::GetInstance();
        auto* const pDevice = pEnv->GetDevice();

        RefCntAutoPtr<IPipelineState> pPSO;
        pEnv->SetErrorAllowance(2, ""Errors below are expected: testing PSO creation failure\\n"");
        pEnv->PushExpectedErrorSubstring(ExpectedErrorSubstring);
        pDevice->CreateGraphicsPipelineState(CI, &pPSO);
        ASSERT_FALSE(pPSO);

        CI.PSODesc.Name = nullptr;
        pEnv->SetErrorAllowance(2);
        pEnv->PushExpectedErrorSubstring(ExpectedErrorSubstring);
        pDevice->CreateGraphicsPipelineState(CI, &pPSO);
        ASSERT_FALSE(pPSO);

        pEnv->SetErrorAllowance(0);
    }

    static void TestCreatePSOFailure(ComputePipelineStateCreateInfo CI, const char* ExpectedErrorSubstring)
    {
        auto* const pEnv    = TestingEnvironment::GetInstance();
        auto* const pDevice = pEnv->GetDevice();

        RefCntAutoPtr<IPipelineState> pPSO;

        pEnv->SetErrorAllowance(2, ""Errors below are expected: testing PSO creation failure\\n"");
        pEnv->PushExpectedErrorSubstring(ExpectedErrorSubstring);
        pDevice->CreateComputePipelineState(CI, &pPSO);
        ASSERT_FALSE(pPSO);

        CI.PSODesc.Name = nullptr;
        pEnv->SetErrorAllowance(2);
        pEnv->PushExpectedErrorSubstring(ExpectedErrorSubstring);
        pDevice->CreateComputePipelineState(CI, &pPSO);
        ASSERT_FALSE(pPSO);

        pEnv->SetErrorAllowance(0);
    }

    static void TestCreatePSOFailure(RayTracingPipelineStateCreateInfo CI, const char* ExpectedErrorSubstring)
    {
        auto* const pEnv    = TestingEnvironment::GetInstance();
        auto* const pDevice = pEnv->GetDevice();

        RefCntAutoPtr<IPipelineState> pPSO;

        pEnv->SetErrorAllowance(2, ""Errors below are expected: testing PSO creation failure\\n"");
        pEnv->PushExpectedErrorSubstring(ExpectedErrorSubstring);
        pDevice->CreateRayTracingPipelineState(CI, &pPSO);
        ASSERT_FALSE(pPSO);

        CI.PSODesc.Name = nullptr;
        pEnv->SetErrorAllowance(2);
        pEnv->PushExpectedErrorSubstring(ExpectedErrorSubstring);
        pDevice->CreateRayTracingPipelineState(CI, &pPSO);
        ASSERT_FALSE(pPSO);

        pEnv->SetErrorAllowance(0);
    }

protected:
    static RefCntAutoPtr<IPipelineResourceSignature> sm_pSignature0;
    static RefCntAutoPtr<IPipelineResourceSignature> sm_pSignature0A;
    static RefCntAutoPtr<IPipelineResourceSignature> sm_pSignature1;
    static RefCntAutoPtr<IPipelineResourceSignature> sm_pSignature1A;

private:
    static RefCntAutoPtr<IShader>     sm_pTrivialVS;
    static RefCntAutoPtr<IShader>     sm_pTrivialPS;
    static RefCntAutoPtr<IShader>     sm_pTrivialPS_DXC;
    static RefCntAutoPtr<IShader>     sm_pTexturePS;
    static RefCntAutoPtr<IShader>     sm_pTrivialMS;
    static RefCntAutoPtr<IShader>     sm_pTrivialRG;
    static RefCntAutoPtr<IShader>     sm_pTrivialRMiss;
    static RefCntAutoPtr<IShader>     sm_pTrivialRCHit;
    static RefCntAutoPtr<IShader>     sm_pTrivialRAHit;
    static RefCntAutoPtr<IShader>     sm_pTrivialRInt;
    static RefCntAutoPtr<IShader>     sm_pTrivialRCall;
    static RefCntAutoPtr<IShader>     sm_pTrivialCS;
    static RefCntAutoPtr<IRenderPass> sm_pRenderPass;

    static GraphicsPipelineStateCreateInfo   sm_DefaultGraphicsPsoCI;
    static GraphicsPipelineStateCreateInfo   sm_DefaultMeshPsoCI;
    static ComputePipelineStateCreateInfo    sm_DefaultComputePsoCI;
    static RayTracingPipelineStateCreateInfo sm_DefaultRayTracingPsoCI;

    static std::array<RayTracingGeneralShaderGroup, 1> sm_GeneralGroups;

    static bool sm_HasMeshShader;
    static bool sm_HasRayTracing;
};

RefCntAutoPtr<IShader>                    PSOCreationFailureTest::sm_pTrivialVS;
RefCntAutoPtr<IShader>                    PSOCreationFailureTest::sm_pTrivialPS;
RefCntAutoPtr<IShader>                    PSOCreationFailureTest::sm_pTexturePS;
RefCntAutoPtr<IShader>                    PSOCreationFailureTest::sm_pTrivialPS_DXC;
RefCntAutoPtr<IShader>                    PSOCreationFailureTest::sm_pTrivialMS;
RefCntAutoPtr<IShader>                    PSOCreationFailureTest::sm_pTrivialCS;
RefCntAutoPtr<IShader>                    PSOCreationFailureTest::sm_pTrivialRG;
RefCntAutoPtr<IShader>                    PSOCreationFailureTest::sm_pTrivialRMiss;
RefCntAutoPtr<IShader>                    PSOCreationFailureTest::sm_pTrivialRCHit;
RefCntAutoPtr<IShader>                    PSOCreationFailureTest::sm_pTrivialRAHit;
RefCntAutoPtr<IShader>                    PSOCreationFailureTest::sm_pTrivialRInt;
RefCntAutoPtr<IShader>                    PSOCreationFailureTest::sm_pTrivialRCall;
RefCntAutoPtr<IRenderPass>                PSOCreationFailureTest::sm_pRenderPass;
RefCntAutoPtr<IPipelineResourceSignature> PSOCreationFailureTest::sm_pSignature0;
RefCntAutoPtr<IPipelineResourceSignature> PSOCreationFailureTest::sm_pSignature0A;
RefCntAutoPtr<IPipelineResourceSignature> PSOCreationFailureTest::sm_pSignature1;
RefCntAutoPtr<IPipelineResourceSignature> PSOCreationFailureTest::sm_pSignature1A;

GraphicsPipelineStateCreateInfo   PSOCreationFailureTest::sm_DefaultGraphicsPsoCI;
GraphicsPipelineStateCreateInfo   PSOCreationFailureTest::sm_DefaultMeshPsoCI;
ComputePipelineStateCreateInfo    PSOCreationFailureTest::sm_DefaultComputePsoCI;
RayTracingPipelineStateCreateInfo PSOCreationFailureTest::sm_DefaultRayTracingPsoCI;

std::array<RayTracingGeneralShaderGroup, 1> PSOCreationFailureTest::sm_GeneralGroups;

bool PSOCreationFailureTest::sm_HasMeshShader;
bool PSOCreationFailureTest::sm_HasRayTracing;


TEST_F(PSOCreationFailureTest, InvalidGraphicsPipelineType)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid Graphics Pipeline Type"")};
    PsoCI.PSODesc.PipelineType = PIPELINE_TYPE_COMPUTE;
    TestCreatePSOFailure(PsoCI, ""Pipeline type must be GRAPHICS or MESH"");
}

TEST_F(PSOCreationFailureTest, NoVS)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - no VS"")};
    PsoCI.pVS = nullptr;
    TestCreatePSOFailure(PsoCI, ""Vertex shader must not be null"");
}

TEST_F(PSOCreationFailureTest, IncorrectVSType)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - incorrect VS Type"")};
    PsoCI.pVS = GetPS();
    TestCreatePSOFailure(PsoCI, ""SHADER_TYPE_PIXEL is not a valid type for vertex shader"");
}

TEST_F(PSOCreationFailureTest, IncorrectPSType)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - incorrect PS Type"")};
    PsoCI.pPS = GetVS();
    TestCreatePSOFailure(PsoCI, ""SHADER_TYPE_VERTEX is not a valid type for pixel shader"");
}

TEST_F(PSOCreationFailureTest, IncorrectGSType)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - incorrect GS Type"")};
    PsoCI.pGS = GetVS();
    TestCreatePSOFailure(PsoCI, ""SHADER_TYPE_VERTEX is not a valid type for geometry shader"");
}

TEST_F(PSOCreationFailureTest, IncorrectDSType)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - incorrect DS Type"")};
    PsoCI.pDS = GetVS();
    TestCreatePSOFailure(PsoCI, ""SHADER_TYPE_VERTEX is not a valid type for domain shader"");
}

TEST_F(PSOCreationFailureTest, IncorrectHSType)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - incorrect HS Type"")};
    PsoCI.pHS = GetVS();
    TestCreatePSOFailure(PsoCI, ""SHADER_TYPE_VERTEX is not a valid type for hull shader"");
}

TEST_F(PSOCreationFailureTest, WrongSubpassIndex)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - wrong subpass index"")};
    PsoCI.GraphicsPipeline.SubpassIndex = 1;
    TestCreatePSOFailure(PsoCI, ""Subpass index (1) must be 0"");
}

TEST_F(PSOCreationFailureTest, UndefinedFillMode)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Undefined Fill Mode"")};
    PsoCI.GraphicsPipeline.RasterizerDesc.FillMode = FILL_MODE_UNDEFINED;
    TestCreatePSOFailure(PsoCI, ""RasterizerDesc.FillMode must not be FILL_MODE_UNDEFINED"");
}

TEST_F(PSOCreationFailureTest, UndefinedCullMode)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Undefined Cull Mode"")};
    PsoCI.GraphicsPipeline.RasterizerDesc.CullMode = CULL_MODE_UNDEFINED;
    TestCreatePSOFailure(PsoCI, ""RasterizerDesc.CullMode must not be CULL_MODE_UNDEFINED"");
}

TEST_F(PSOCreationFailureTest, InvalidDepthFunc)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid Depth Func"")};
    PsoCI.GraphicsPipeline.DepthStencilDesc.DepthFunc = COMPARISON_FUNC_UNKNOWN;
    TestCreatePSOFailure(PsoCI, ""DepthStencilDesc.DepthFunc must not be COMPARISON_FUNC_UNKNOWN"");
}

TEST_F(PSOCreationFailureTest, InvalidFrontStencilFailOp)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid Front Face StencilFailOp"")};
    PsoCI.GraphicsPipeline.DepthStencilDesc.StencilEnable           = True;
    PsoCI.GraphicsPipeline.DepthStencilDesc.FrontFace.StencilFailOp = STENCIL_OP_UNDEFINED;
    TestCreatePSOFailure(PsoCI, ""DepthStencilDesc.FrontFace.StencilFailOp must not be STENCIL_OP_UNDEFINED"");
}

TEST_F(PSOCreationFailureTest, InvalidBackStencilFailOp)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid Back Face StencilFailOp"")};
    PsoCI.GraphicsPipeline.DepthStencilDesc.StencilEnable          = True;
    PsoCI.GraphicsPipeline.DepthStencilDesc.BackFace.StencilFailOp = STENCIL_OP_UNDEFINED;
    TestCreatePSOFailure(PsoCI, ""DepthStencilDesc.BackFace.StencilFailOp must not be STENCIL_OP_UNDEFINED"");
}

TEST_F(PSOCreationFailureTest, InvalidFrontStencilDepthFailOp)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid Front Face StencilDepthFailOp"")};
    PsoCI.GraphicsPipeline.DepthStencilDesc.StencilEnable                = True;
    PsoCI.GraphicsPipeline.DepthStencilDesc.FrontFace.StencilDepthFailOp = STENCIL_OP_UNDEFINED;
    TestCreatePSOFailure(PsoCI, ""DepthStencilDesc.FrontFace.StencilDepthFailOp must not be STENCIL_OP_UNDEFINED"");
}

TEST_F(PSOCreationFailureTest, InvalidBackStencilDepthFailOp)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid Back Face StencilDepthFailOp"")};
    PsoCI.GraphicsPipeline.DepthStencilDesc.StencilEnable               = True;
    PsoCI.GraphicsPipeline.DepthStencilDesc.BackFace.StencilDepthFailOp = STENCIL_OP_UNDEFINED;
    TestCreatePSOFailure(PsoCI, ""DepthStencilDesc.BackFace.StencilDepthFailOp must not be STENCIL_OP_UNDEFINED"");
}

TEST_F(PSOCreationFailureTest, InvalidFrontStencilPassOp)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid Front Face StencilPassOp"")};
    PsoCI.GraphicsPipeline.DepthStencilDesc.StencilEnable           = True;
    PsoCI.GraphicsPipeline.DepthStencilDesc.FrontFace.StencilPassOp = STENCIL_OP_UNDEFINED;
    TestCreatePSOFailure(PsoCI, ""DepthStencilDesc.FrontFace.StencilPassOp must not be STENCIL_OP_UNDEFINED"");
}

TEST_F(PSOCreationFailureTest, InvalidBackStencilPassOp)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid Back Face StencilPassOp"")};
    PsoCI.GraphicsPipeline.DepthStencilDesc.StencilEnable          = True;
    PsoCI.GraphicsPipeline.DepthStencilDesc.BackFace.StencilPassOp = STENCIL_OP_UNDEFINED;
    TestCreatePSOFailure(PsoCI, ""DepthStencilDesc.BackFace.StencilPassOp must not be STENCIL_OP_UNDEFINED"");
}

TEST_F(PSOCreationFailureTest, InvalidFrontStencilFunc)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid Front Face StencilFunc"")};
    PsoCI.GraphicsPipeline.DepthStencilDesc.StencilEnable         = True;
    PsoCI.GraphicsPipeline.DepthStencilDesc.FrontFace.StencilFunc = COMPARISON_FUNC_UNKNOWN;
    TestCreatePSOFailure(PsoCI, ""DepthStencilDesc.FrontFace.StencilFunc must not be COMPARISON_FUNC_UNKNOWN"");
}

TEST_F(PSOCreationFailureTest, InvalidBackStencilFunc)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid Back Face StencilFunc"")};
    PsoCI.GraphicsPipeline.DepthStencilDesc.StencilEnable        = True;
    PsoCI.GraphicsPipeline.DepthStencilDesc.BackFace.StencilFunc = COMPARISON_FUNC_UNKNOWN;
    TestCreatePSOFailure(PsoCI, ""DepthStencilDesc.BackFace.StencilFunc must not be COMPARISON_FUNC_UNKNOWN"");
}

TEST_F(PSOCreationFailureTest, InvalidSrcBlend)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid SrcBlend"")};
    PsoCI.GraphicsPipeline.BlendDesc.RenderTargets[0].BlendEnable = True;
    PsoCI.GraphicsPipeline.BlendDesc.RenderTargets[0].SrcBlend    = BLEND_FACTOR_UNDEFINED;
    TestCreatePSOFailure(PsoCI, ""BlendDesc.RenderTargets[0].SrcBlend must not be BLEND_FACTOR_UNDEFINED"");
}

TEST_F(PSOCreationFailureTest, InvalidDestBlend)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid DestBlend"")};
    PsoCI.GraphicsPipeline.BlendDesc.RenderTargets[0].BlendEnable = True;
    PsoCI.GraphicsPipeline.BlendDesc.RenderTargets[0].DestBlend   = BLEND_FACTOR_UNDEFINED;
    TestCreatePSOFailure(PsoCI, ""BlendDesc.RenderTargets[0].DestBlend must not be BLEND_FACTOR_UNDEFINED"");
}

TEST_F(PSOCreationFailureTest, InvalidBlendOp)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid BlendOp"")};
    PsoCI.GraphicsPipeline.BlendDesc.RenderTargets[0].BlendEnable = True;
    PsoCI.GraphicsPipeline.BlendDesc.RenderTargets[0].BlendOp     = BLEND_OPERATION_UNDEFINED;
    TestCreatePSOFailure(PsoCI, ""BlendDesc.RenderTargets[0].BlendOp must not be BLEND_OPERATION_UNDEFINED"");
}

TEST_F(PSOCreationFailureTest, InvalidSrcBlendAlpha)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid SrcBlendAlpha"")};
    PsoCI.GraphicsPipeline.BlendDesc.RenderTargets[0].BlendEnable   = True;
    PsoCI.GraphicsPipeline.BlendDesc.RenderTargets[0].SrcBlendAlpha = BLEND_FACTOR_UNDEFINED;
    TestCreatePSOFailure(PsoCI, ""BlendDesc.RenderTargets[0].SrcBlendAlpha must not be BLEND_FACTOR_UNDEFINED"");
}

TEST_F(PSOCreationFailureTest, InvalidDestBlendAlpha)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid DestBlendAlpha"")};
    PsoCI.GraphicsPipeline.BlendDesc.RenderTargets[0].BlendEnable    = True;
    PsoCI.GraphicsPipeline.BlendDesc.RenderTargets[0].DestBlendAlpha = BLEND_FACTOR_UNDEFINED;
    TestCreatePSOFailure(PsoCI, ""BlendDesc.RenderTargets[0].DestBlendAlpha must not be BLEND_FACTOR_UNDEFINED"");
}

TEST_F(PSOCreationFailureTest, InvalidBlendOpAlpha)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid BlendOpAlpha"")};
    PsoCI.GraphicsPipeline.BlendDesc.RenderTargets[0].BlendEnable  = True;
    PsoCI.GraphicsPipeline.BlendDesc.RenderTargets[0].BlendOpAlpha = BLEND_OPERATION_UNDEFINED;
    TestCreatePSOFailure(PsoCI, ""BlendDesc.RenderTargets[0].BlendOpAlpha must not be BLEND_OPERATION_UNDEFINED"");
}

TEST_F(PSOCreationFailureTest, NullVariableName)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - null variable name"")};

    ShaderResourceVariableDesc Variables[] //
        {
            ShaderResourceVariableDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_Texture"", SHADER_RESOURCE_VARIABLE_TYPE_STATIC},
            ShaderResourceVariableDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, nullptr, SHADER_RESOURCE_VARIABLE_TYPE_STATIC} //
        };
    PsoCI.PSODesc.ResourceLayout.Variables    = Variables;
    PsoCI.PSODesc.ResourceLayout.NumVariables = _countof(Variables);
    TestCreatePSOFailure(PsoCI, ""ResourceLayout.Variables[1].Name must not be null"");
}

TEST_F(PSOCreationFailureTest, EmptyVariableName)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - empty variable name"")};

    ShaderResourceVariableDesc Variables[] //
        {
            ShaderResourceVariableDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_Texture"", SHADER_RESOURCE_VARIABLE_TYPE_STATIC},
            ShaderResourceVariableDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, """", SHADER_RESOURCE_VARIABLE_TYPE_STATIC} //
        };
    PsoCI.PSODesc.ResourceLayout.Variables    = Variables;
    PsoCI.PSODesc.ResourceLayout.NumVariables = _countof(Variables);
    TestCreatePSOFailure(PsoCI, ""ResourceLayout.Variables[1].Name must not be empty"");
}

TEST_F(PSOCreationFailureTest, UnknownVariableShaderStage)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - unknown variable shader stage"")};

    ShaderResourceVariableDesc Variables[] //
        {
            ShaderResourceVariableDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_Texture"", SHADER_RESOURCE_VARIABLE_TYPE_STATIC},
            ShaderResourceVariableDesc{SHADER_TYPE_UNKNOWN, ""g_Texture2"", SHADER_RESOURCE_VARIABLE_TYPE_STATIC} //
        };
    PsoCI.PSODesc.ResourceLayout.Variables    = Variables;
    PsoCI.PSODesc.ResourceLayout.NumVariables = _countof(Variables);
    TestCreatePSOFailure(PsoCI, ""ResourceLayout.Variables[1].ShaderStages must not be SHADER_TYPE_UNKNOWN"");
}


TEST_F(PSOCreationFailureTest, OverlappingVariableStages)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Overlapping Variable Stages"")};

    ShaderResourceVariableDesc Variables[] //
        {
            ShaderResourceVariableDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_Texture"", SHADER_RESOURCE_VARIABLE_TYPE_STATIC},
            ShaderResourceVariableDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_GEOMETRY, ""g_Texture"", SHADER_RESOURCE_VARIABLE_TYPE_STATIC} //
        };
    PsoCI.PSODesc.ResourceLayout.Variables    = Variables;
    PsoCI.PSODesc.ResourceLayout.NumVariables = _countof(Variables);
    TestCreatePSOFailure(PsoCI, ""'g_Texture' is defined in overlapping shader stages (SHADER_TYPE_VERTEX, SHADER_TYPE_GEOMETRY and SHADER_TYPE_VERTEX, SHADER_TYPE_PIXEL)"");
}


TEST_F(PSOCreationFailureTest, NullImmutableSamplerName)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - null immutable sampler name"")};

    ImmutableSamplerDesc ImtblSamplers[] //
        {
            ImmutableSamplerDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_Texture_sampler"", SamplerDesc{}},
            ImmutableSamplerDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, nullptr, SamplerDesc{}} //
        };
    PsoCI.PSODesc.ResourceLayout.ImmutableSamplers    = ImtblSamplers;
    PsoCI.PSODesc.ResourceLayout.NumImmutableSamplers = _countof(ImtblSamplers);
    TestCreatePSOFailure(PsoCI, ""ResourceLayout.ImmutableSamplers[1].SamplerOrTextureName must not be null"");
}

TEST_F(PSOCreationFailureTest, EmptyImmutableSamplerName)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - empty immutable sampler name"")};

    ImmutableSamplerDesc ImtblSamplers[] //
        {
            ImmutableSamplerDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_Texture_sampler"", SamplerDesc{}},
            ImmutableSamplerDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, """", SamplerDesc{}} //
        };
    PsoCI.PSODesc.ResourceLayout.ImmutableSamplers    = ImtblSamplers;
    PsoCI.PSODesc.ResourceLayout.NumImmutableSamplers = _countof(ImtblSamplers);
    TestCreatePSOFailure(PsoCI, ""ResourceLayout.ImmutableSamplers[1].SamplerOrTextureName must not be empty"");
}

TEST_F(PSOCreationFailureTest, UndefinedImmutableSamplerShaderStages)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - undefined immutable sampler shader stages"")};

    ImmutableSamplerDesc ImtblSamplers[] //
        {
            ImmutableSamplerDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_Texture_sampler"", SamplerDesc{}},
            ImmutableSamplerDesc{SHADER_TYPE_UNKNOWN, ""g_Texture_sampler2"", SamplerDesc{}} //
        };
    PsoCI.PSODesc.ResourceLayout.ImmutableSamplers    = ImtblSamplers;
    PsoCI.PSODesc.ResourceLayout.NumImmutableSamplers = _countof(ImtblSamplers);
    TestCreatePSOFailure(PsoCI, ""ResourceLayout.ImmutableSamplers[1].ShaderStages must not be SHADER_TYPE_UNKNOWN"");
}

TEST_F(PSOCreationFailureTest, OverlappingImmutableSamplerStages)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Overlapping Immutable Sampler Stages"")};

    ImmutableSamplerDesc ImtblSamplers[] //
        {
            ImmutableSamplerDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_PIXEL, ""g_Texture_sampler"", SamplerDesc{}},
            ImmutableSamplerDesc{SHADER_TYPE_VERTEX | SHADER_TYPE_GEOMETRY, ""g_Texture_sampler"", SamplerDesc{}} //
        };
    PsoCI.PSODesc.ResourceLayout.ImmutableSamplers    = ImtblSamplers;
    PsoCI.PSODesc.ResourceLayout.NumImmutableSamplers = _countof(ImtblSamplers);
    TestCreatePSOFailure(PsoCI, ""'g_Texture_sampler' is defined in overlapping shader stages (SHADER_TYPE_VERTEX, SHADER_TYPE_GEOMETRY and SHADER_TYPE_VERTEX, SHADER_TYPE_PIXEL)"");
}

TEST_F(PSOCreationFailureTest, RenderPassWithNonZeroNumRenderTargets)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Render Pass With non-zero NumRenderTargets"", true)};
    PsoCI.GraphicsPipeline.NumRenderTargets = 1;
    TestCreatePSOFailure(PsoCI, ""NumRenderTargets must be 0"");
}

TEST_F(PSOCreationFailureTest, RenderPassWithDSVFormat)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Render Pass With defined DSV format"", true)};
    PsoCI.GraphicsPipeline.DSVFormat = TEX_FORMAT_D32_FLOAT;
    TestCreatePSOFailure(PsoCI, ""DSVFormat must be TEX_FORMAT_UNKNOWN"");
}

TEST_F(PSOCreationFailureTest, RenderPassWithRTVFormat)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Render Pass With defined RTV format"", true)};
    PsoCI.GraphicsPipeline.RTVFormats[1] = TEX_FORMAT_RGBA8_UNORM;
    TestCreatePSOFailure(PsoCI, ""RTVFormats[1] must be TEX_FORMAT_UNKNOWN"");
}

TEST_F(PSOCreationFailureTest, RenderPassWithInvalidSubpassIndex)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Render Pass With invalid Subpass index"", true)};
    PsoCI.GraphicsPipeline.SubpassIndex = 2;
    TestCreatePSOFailure(PsoCI, ""Subpass index (2) exceeds the number of subpasses (1)"");
}

TEST_F(PSOCreationFailureTest, NullResourceSignatures)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Null Resource Signatures"", true)};
    PsoCI.ResourceSignaturesCount = 2;
    TestCreatePSOFailure(PsoCI, ""ppResourceSignatures is null, but ResourceSignaturesCount (2) is not zero"");
}

TEST_F(PSOCreationFailureTest, ZeroResourceSignaturesCount)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Zero Resource Signatures Count"", true)};

    IPipelineResourceSignature* pSignatures[] = {sm_pSignature0};
    PsoCI.ppResourceSignatures                = pSignatures;
    PsoCI.ResourceSignaturesCount             = 0;
    TestCreatePSOFailure(PsoCI, ""ppResourceSignatures is not null, but ResourceSignaturesCount is zero."");
}


TEST_F(PSOCreationFailureTest, SignatureWithNonZeroNumVariables)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Resource Signature With non-zero NumVariables"", true)};

    IPipelineResourceSignature* pSignatures[] = {sm_pSignature0};
    PsoCI.ppResourceSignatures                = pSignatures;
    PsoCI.ResourceSignaturesCount             = _countof(pSignatures);
    PsoCI.PSODesc.ResourceLayout.NumVariables = 3;
    TestCreatePSOFailure(PsoCI, ""The number of variables defined through resource layout (3) must be zero"");
}

TEST_F(PSOCreationFailureTest, SignatureWithNonZeroNumImmutableSamplers)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Resource Signature With non-zero NumImmutableSamplers"", true)};

    IPipelineResourceSignature* pSignatures[]         = {sm_pSignature0};
    PsoCI.ppResourceSignatures                        = pSignatures;
    PsoCI.ResourceSignaturesCount                     = _countof(pSignatures);
    PsoCI.PSODesc.ResourceLayout.NumImmutableSamplers = 4;
    TestCreatePSOFailure(PsoCI, ""The number of immutable samplers defined through resource layout (4) must be zero"");
}

TEST_F(PSOCreationFailureTest, NullSignature)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Null Signature"", true)};

    IPipelineResourceSignature* pSignatures[] = {sm_pSignature0, nullptr};
    PsoCI.ppResourceSignatures                = pSignatures;
    PsoCI.ResourceSignaturesCount             = _countof(pSignatures);
    TestCreatePSOFailure(PsoCI, ""signature at index 1 is null"");
}

TEST_F(PSOCreationFailureTest, ConflictingSignatureBindIndex)
{
    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Conflicting Signature Bind Index"", true)};

    IPipelineResourceSignature* pSignatures[] = {sm_pSignature0, sm_pSignature0A};
    PsoCI.ppResourceSignatures                = pSignatures;
    PsoCI.ResourceSignaturesCount             = _countof(pSignatures);
    TestCreatePSOFailure(PsoCI, ""'PRS0A' at binding index 0 conflicts with another resource signature 'PRS0'"");
}

TEST_F(PSOCreationFailureTest, ConflictingSignatureResourceStages)
{
    if (!sm_pSignature1)
        GTEST_SKIP();

    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - conflicting signature resource stages"", true)};

    IPipelineResourceSignature* pSignatures[] = {sm_pSignature0, sm_pSignature1};
    PsoCI.ppResourceSignatures                = pSignatures;
    PsoCI.ResourceSignaturesCount             = _countof(pSignatures);
    TestCreatePSOFailure(PsoCI, ""Shader resource 'g_Texture' is found in more than one resource signature ('PRS1' and 'PRS0')"");
}

TEST_F(PSOCreationFailureTest, ConflictingImmutableSamplerStages)
{
    if (!sm_pSignature1A)
        GTEST_SKIP();

    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - conflicting signature immutable sampler stages"", true)};

    IPipelineResourceSignature* pSignatures[] = {sm_pSignature0, sm_pSignature1A};
    PsoCI.ppResourceSignatures                = pSignatures;
    PsoCI.ResourceSignaturesCount             = _countof(pSignatures);

    // In case of non-separable programs, there is another error - a resource (""g_Texture"") is found in different signatures
    const auto* ExpectedError = TestingEnvironment::GetInstance()->GetDevice()->GetDeviceCaps().Features.SeparablePrograms ?
        ""Immutable sampler 'g_Texture_sampler' is found in more than one resource signature ('PRS1A' and 'PRS0')"" :
        ""shader resource 'g_Texture' is found in more than one resource signature ('PRS1A' and 'PRS0')"";
    TestCreatePSOFailure(PsoCI, ExpectedError);
}

TEST_F(PSOCreationFailureTest, InvalidComputePipelineType)
{
    auto PsoCI{GetComputePSOCreateInfo(""PSO Create Failure - Invalid Compute Pipeline Type"")};
    PsoCI.PSODesc.PipelineType = PIPELINE_TYPE_GRAPHICS;
    TestCreatePSOFailure(PsoCI, ""Pipeline type must be COMPUTE"");
}

TEST_F(PSOCreationFailureTest, NoCS)
{
    auto PsoCI{GetComputePSOCreateInfo(""PSO Create Failure - no CS"")};
    PsoCI.pCS = nullptr;
    TestCreatePSOFailure(PsoCI, ""Compute shader must not be null"");
}

TEST_F(PSOCreationFailureTest, InvalidCS)
{
    auto PsoCI{GetComputePSOCreateInfo(""PSO Create Failure - invalid CS"")};
    PsoCI.pCS = GetPS();
    TestCreatePSOFailure(PsoCI, ""SHADER_TYPE_PIXEL is not a valid type for compute shader"");
}

TEST_F(PSOCreationFailureTest, NullMS)
{
    if (!HasMeshShader())
        GTEST_SKIP();

    auto PsoCI{GetMeshPSOCreateInfo(""PSO Create Failure - null MS"")};
    PsoCI.pMS = nullptr;
    TestCreatePSOFailure(PsoCI, ""Mesh shader must not be null"");
}

TEST_F(PSOCreationFailureTest, InvalidMS)
{
    if (!HasMeshShader())
        GTEST_SKIP();

    auto PsoCI{GetMeshPSOCreateInfo(""PSO Create Failure - Invalid MS"")};
    PsoCI.pMS = GetPS();
    TestCreatePSOFailure(PsoCI, ""SHADER_TYPE_PIXEL is not a valid type for mesh shader"");
}

TEST_F(PSOCreationFailureTest, NullRG)
{
    if (!HasRayTracing())
        GTEST_SKIP();

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - NUll ray-gen shader"")};
    PsoCI.pGeneralShaders    = nullptr;
    PsoCI.GeneralShaderCount = 0;
    TestCreatePSOFailure(PsoCI, ""At least one shader with type SHADER_TYPE_RAY_GEN must be provided"");
}

TEST_F(PSOCreationFailureTest, InvalidRTPipelineType)
{
    if (!HasRayTracing())
        GTEST_SKIP();

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - Invalid RT pipeline type"")};
    PsoCI.PSODesc.PipelineType = PIPELINE_TYPE_COMPUTE;
    TestCreatePSOFailure(PsoCI, ""Pipeline type must be RAY_TRACING"");
}

TEST_F(PSOCreationFailureTest, InvalidShaderRecord)
{
    if (!HasRayTracing() || !TestingEnvironment::GetInstance()->GetDevice()->GetDeviceCaps().IsD3DDevice())
        GTEST_SKIP();

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - Invalid shader record"")};
    PsoCI.pShaderRecordName                   = ""ShaderRecord"";
    PsoCI.RayTracingPipeline.ShaderRecordSize = 0;
    TestCreatePSOFailure(PsoCI, ""pShaderRecordName must not be null if RayTracingPipeline.ShaderRecordSize is not zero"");
}

TEST_F(PSOCreationFailureTest, TooBigRayRecursionDepth)
{
    if (!HasRayTracing())
        GTEST_SKIP();

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - too big ray recursion depth"")};
    PsoCI.RayTracingPipeline.MaxRecursionDepth = std::numeric_limits<decltype(PsoCI.RayTracingPipeline.MaxRecursionDepth)>::max();
    TestCreatePSOFailure(PsoCI, ""MaxRecursionDepth (255) exceeds device limit"");
}

TEST_F(PSOCreationFailureTest, NullShaderGroupName)
{
    if (!HasRayTracing())
        GTEST_SKIP();

    const RayTracingGeneralShaderGroup GeneralGroups[] = {{""Main"", GetRayGen()}, {nullptr, GetRayMiss()}};

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - null shader group name"")};
    PsoCI.pGeneralShaders    = GeneralGroups;
    PsoCI.GeneralShaderCount = _countof(GeneralGroups);
    TestCreatePSOFailure(PsoCI, ""pGeneralShaders[1].Name must not be null"");
}

TEST_F(PSOCreationFailureTest, EmptyShaderGroupName)
{
    if (!HasRayTracing())
        GTEST_SKIP();

    const RayTracingGeneralShaderGroup GeneralGroups[] = {{""Main"", GetRayGen()}, {"""", GetRayMiss()}};

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - empty shader group name"")};
    PsoCI.pGeneralShaders    = GeneralGroups;
    PsoCI.GeneralShaderCount = _countof(GeneralGroups);
    TestCreatePSOFailure(PsoCI, ""pGeneralShaders[1].Name must not be empty"");
}

TEST_F(PSOCreationFailureTest, NonUniqueShaderGroupName)
{
    if (!HasRayTracing())
        GTEST_SKIP();

    const RayTracingGeneralShaderGroup GeneralGroups[] = {{""Main"", GetRayGen()}, {""Main"", GetRayMiss()}};

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - non-unique shader group name"")};
    PsoCI.pGeneralShaders    = GeneralGroups;
    PsoCI.GeneralShaderCount = _countof(GeneralGroups);
    TestCreatePSOFailure(PsoCI, ""pGeneralShaders[1].Name ('Main') has already been assigned to another group. All group names must be unique."");
}

TEST_F(PSOCreationFailureTest, NullGeneralShader)
{
    if (!HasRayTracing())
        GTEST_SKIP();

    const RayTracingGeneralShaderGroup GeneralGroups[] = {{""Main"", GetRayGen()}, {""Entry"", nullptr}};

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - null general shader"")};
    PsoCI.pGeneralShaders    = GeneralGroups;
    PsoCI.GeneralShaderCount = _countof(GeneralGroups);
    TestCreatePSOFailure(PsoCI, ""pGeneralShaders[1].pShader must not be null"");
}

TEST_F(PSOCreationFailureTest, NullTriHitShader)
{
    if (!HasRayTracing())
        GTEST_SKIP();

    const RayTracingTriangleHitShaderGroup HitGroups[] = {{""ClosestHit"", nullptr}};

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - null triangle closest hit shader"")};
    PsoCI.pTriangleHitShaders    = HitGroups;
    PsoCI.TriangleHitShaderCount = _countof(HitGroups);
    TestCreatePSOFailure(PsoCI, ""pTriangleHitShaders[0].pClosestHitShader must not be null"");
}

TEST_F(PSOCreationFailureTest, NullProcHitShader)
{
    if (!HasRayTracing())
        GTEST_SKIP();

    const RayTracingProceduralHitShaderGroup HitGroups[] = {{""Intersection"", nullptr}};

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - null procedural intersection shader"")};
    PsoCI.pProceduralHitShaders    = HitGroups;
    PsoCI.ProceduralHitShaderCount = _countof(HitGroups);
    TestCreatePSOFailure(PsoCI, ""pProceduralHitShaders[0].pIntersectionShader must not be null"");
}

TEST_F(PSOCreationFailureTest, InvalidShaderinGeneralGroup)
{
    if (!HasRayTracing())
        GTEST_SKIP();

    const RayTracingGeneralShaderGroup GeneralGroups[] = {{""Main"", GetRayGen()}, {""Miss"", GetRayMiss()}, {""Call"", GetCallable()}, {""Hit"", GetRayClosestHit()}};

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - invalid shader in general group"")};
    PsoCI.pGeneralShaders    = GeneralGroups;
    PsoCI.GeneralShaderCount = _countof(GeneralGroups);
    TestCreatePSOFailure(PsoCI, ""SHADER_TYPE_RAY_CLOSEST_HIT is not a valid type for ray tracing general shader"");
}

TEST_F(PSOCreationFailureTest, InvalidShaderinTriangleHitGroup1)
{
    if (!HasRayTracing())
        GTEST_SKIP();

    const RayTracingTriangleHitShaderGroup HitGroups[] = {
        {""CHit"", GetRayClosestHit(), nullptr},
        {""CHit-AHit"", GetRayClosestHit(), GetRayAnyHit()},
        {""Miss"", GetRayMiss()} //
    };

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - invalid shader in triangle hit group - 1"")};
    PsoCI.pTriangleHitShaders    = HitGroups;
    PsoCI.TriangleHitShaderCount = _countof(HitGroups);
    TestCreatePSOFailure(PsoCI, ""SHADER_TYPE_RAY_MISS is not a valid type for ray tracing triangle closest hit"");
}

TEST_F(PSOCreationFailureTest, InvalidShaderinTriangleHitGroup2)
{
    if (!HasRayTracing())
        GTEST_SKIP();

    const RayTracingTriangleHitShaderGroup HitGroups[] = {
        {""CHit"", GetRayClosestHit(), nullptr},
        {""CHit-AHit"", GetRayClosestHit(), GetRayAnyHit()},
        {""CHit-Miss"", GetRayClosestHit(), GetRayIntersection()} //
    };

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - invalid shader in triangle hit group - 2"")};
    PsoCI.pTriangleHitShaders    = HitGroups;
    PsoCI.TriangleHitShaderCount = _countof(HitGroups);
    TestCreatePSOFailure(PsoCI, ""SHADER_TYPE_RAY_INTERSECTION is not a valid type for ray tracing triangle any hit"");
}

TEST_F(PSOCreationFailureTest, InvalidShaderinProceduralHitGroup1)
{
    if (!HasRayTracing())
        GTEST_SKIP();

    const RayTracingProceduralHitShaderGroup HitGroups[] = {
        {""Int"", GetRayIntersection(), nullptr, nullptr},
        {""Int-CHit"", GetRayIntersection(), GetRayClosestHit(), nullptr},
        {""Int-CHit-AHit"", GetRayIntersection(), GetRayClosestHit(), GetRayAnyHit()},
        {""Call"", GetCallable(), nullptr, nullptr} //
    };

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - invalid shader in procedural hit group - 1"")};
    PsoCI.pProceduralHitShaders    = HitGroups;
    PsoCI.ProceduralHitShaderCount = _countof(HitGroups);
    TestCreatePSOFailure(PsoCI, ""SHADER_TYPE_CALLABLE is not a valid type for ray tracing procedural intersection"");
}

TEST_F(PSOCreationFailureTest, InvalidShaderinProceduralHitGroup2)
{
    if (!HasRayTracing())
        GTEST_SKIP();

    const RayTracingProceduralHitShaderGroup HitGroups[] = {
        {""Int"", GetRayIntersection(), nullptr, nullptr},
        {""Int-CHit"", GetRayIntersection(), GetRayClosestHit(), nullptr},
        {""Int-CHit-AHit"", GetRayIntersection(), GetRayClosestHit(), GetRayAnyHit()},
        {""Int-RG"", GetRayIntersection(), GetRayGen(), nullptr} //
    };

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - invalid shader in procedural hit group - 2"")};
    PsoCI.pProceduralHitShaders    = HitGroups;
    PsoCI.ProceduralHitShaderCount = _countof(HitGroups);
    TestCreatePSOFailure(PsoCI, ""SHADER_TYPE_RAY_GEN is not a valid type for ray tracing procedural closest hit"");
}

TEST_F(PSOCreationFailureTest, InvalidShaderinProceduralHitGroup3)
{
    if (!HasRayTracing())
        GTEST_SKIP();

    const RayTracingProceduralHitShaderGroup HitGroups[] = {
        {""Int"", GetRayIntersection(), nullptr, nullptr},
        {""Int-CHit"", GetRayIntersection(), GetRayClosestHit(), nullptr},
        {""Int-CHit-AHit"", GetRayIntersection(), GetRayClosestHit(), GetRayAnyHit()},
        {""Int-CHit-CHit"", GetRayIntersection(), GetRayClosestHit(), GetRayClosestHit()} //
    };

    auto PsoCI{GetRayTracingPSOCreateInfo(""PSO Create Failure - invalid shader in procedural hit group - 3"")};
    PsoCI.pProceduralHitShaders    = HitGroups;
    PsoCI.ProceduralHitShaderCount = _countof(HitGroups);
    TestCreatePSOFailure(PsoCI, ""SHADER_TYPE_RAY_CLOSEST_HIT is not a valid type for ray tracing procedural any hit"");
}

TEST_F(PSOCreationFailureTest, MissingResource)
{
    PipelineResourceSignatureDesc PRSDesc;
    PRSDesc.Name = ""PSO Create Failure - missing resource"";
    PipelineResourceDesc Resources[]{
        {SHADER_TYPE_PIXEL, ""g_AnotherTexture"", 1, SHADER_RESOURCE_TYPE_TEXTURE_SRV, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE}};
    PRSDesc.UseCombinedTextureSamplers = true;
    PRSDesc.Resources                  = Resources;
    PRSDesc.NumResources               = _countof(Resources);

    auto* pDevice = TestingEnvironment::GetInstance()->GetDevice();

    RefCntAutoPtr<IPipelineResourceSignature> pPRS;
    pDevice->CreatePipelineResourceSignature(PRSDesc, &pPRS);
    ASSERT_NE(pPRS, nullptr);

    IPipelineResourceSignature* ppSignatures[] = {pPRS};

    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - missing resource"")};
    PsoCI.ppResourceSignatures    = ppSignatures;
    PsoCI.ResourceSignaturesCount = _countof(ppSignatures);

    PsoCI.pPS = GetTexturePS();

    std::string ExpectedErrorString = ""contains resource 'g_Texture' that is not present in any pipeline resource signature"";
    if (pDevice->GetDeviceCaps().Features.SeparablePrograms)
        ExpectedErrorString = std::string{""Shader 'TexturePS (PSOCreationFailureTest)' ""} + ExpectedErrorString;
    // In non-separable programs case, PSO name is used instead of the shader name

    TestCreatePSOFailure(PsoCI, ExpectedErrorString.c_str());
}

TEST_F(PSOCreationFailureTest, InvalidResourceType)
{
    PipelineResourceSignatureDesc PRSDesc;
    PRSDesc.Name = ""PSO Create Failure - Invalid Resource Type"";
    PipelineResourceDesc Resources[]{
        {SHADER_TYPE_PIXEL, ""g_Texture"", 1, SHADER_RESOURCE_TYPE_BUFFER_SRV, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE}};
    PRSDesc.UseCombinedTextureSamplers = true;
    PRSDesc.Resources                  = Resources;
    PRSDesc.NumResources               = _countof(Resources);

    auto* pDevice = TestingEnvironment::GetInstance()->GetDevice();

    RefCntAutoPtr<IPipelineResourceSignature> pPRS;
    pDevice->CreatePipelineResourceSignature(PRSDesc, &pPRS);
    ASSERT_NE(pPRS, nullptr);

    IPipelineResourceSignature* ppSignatures[] = {pPRS};

    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid Resource Type"")};
    PsoCI.ppResourceSignatures    = ppSignatures;
    PsoCI.ResourceSignaturesCount = _countof(ppSignatures);

    PsoCI.pPS = GetTexturePS();

    std::string ExpectedErrorString = ""contains resource with name 'g_Texture' and type 'texture SRV' that is not compatible with type 'buffer SRV'"";
    if (pDevice->GetDeviceCaps().Features.SeparablePrograms)
        ExpectedErrorString = std::string{""Shader 'TexturePS (PSOCreationFailureTest)' ""} + ExpectedErrorString;
    // In non-separable programs case, PSO name is used of the shader name

    TestCreatePSOFailure(PsoCI, ExpectedErrorString.c_str());
}

TEST_F(PSOCreationFailureTest, InvalidArraySize)
{
    static constexpr char PSSource[] = R""(
    Texture2D g_Texture[3];
    float4 main() : SV_Target
    {
        return g_Texture[0].Load(int3(0,0,0)) + g_Texture[1].Load(int3(0,0,0)) + g_Texture[2].Load(int3(0,0,0));
    }
    )"";

    auto* const pEnv    = TestingEnvironment::GetInstance();
    auto* const pDevice = pEnv->GetDevice();

    ShaderCreateInfo ShaderCI;
    ShaderCI.Source                     = PSSource;
    ShaderCI.Desc.ShaderType            = SHADER_TYPE_PIXEL;
    ShaderCI.Desc.Name                  = ""Invalid Array Size (PSOCreationFailureTest)"";
    ShaderCI.SourceLanguage             = SHADER_SOURCE_LANGUAGE_HLSL;
    ShaderCI.ShaderCompiler             = pEnv->GetDefaultCompiler(ShaderCI.SourceLanguage);
    ShaderCI.UseCombinedTextureSamplers = true;
    RefCntAutoPtr<IShader> pPS;
    pDevice->CreateShader(ShaderCI, &pPS);

    PipelineResourceSignatureDesc PRSDesc;
    PRSDesc.Name = ""PSO Create Failure - Invalid Array Size"";
    PipelineResourceDesc Resources[]{
        {SHADER_TYPE_PIXEL, ""g_Texture"", 2, SHADER_RESOURCE_TYPE_TEXTURE_SRV, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE}};

    PRSDesc.UseCombinedTextureSamplers = true;
    PRSDesc.Resources                  = Resources;
    PRSDesc.NumResources               = _countof(Resources);

    RefCntAutoPtr<IPipelineResourceSignature> pPRS;
    pDevice->CreatePipelineResourceSignature(PRSDesc, &pPRS);
    ASSERT_NE(pPRS, nullptr);

    IPipelineResourceSignature* ppSignatures[] = {pPRS};

    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid Array Size"")};
    PsoCI.ppResourceSignatures    = ppSignatures;
    PsoCI.ResourceSignaturesCount = _countof(ppSignatures);

    PsoCI.pPS = pPS;

    std::string ExpectedErrorString = ""contains resource 'g_Texture' whose array size (3) is greater than the array size (2)"";
    if (pDevice->GetDeviceCaps().Features.SeparablePrograms)
        ExpectedErrorString = std::string{""Shader 'Invalid Array Size (PSOCreationFailureTest)' ""} + ExpectedErrorString;
    // In non-separable programs case, PSO name is used

    TestCreatePSOFailure(PsoCI, ExpectedErrorString.c_str());
}


TEST_F(PSOCreationFailureTest, InvalidRunTimeArray)
{
    auto* const pEnv       = TestingEnvironment::GetInstance();
    auto* const pDevice    = pEnv->GetDevice();
    const auto& deviceCaps = pDevice->GetDeviceCaps();

    if (!pDevice->GetDeviceCaps().Features.ShaderResourceRuntimeArray)
    {
        GTEST_SKIP();
    }

    static constexpr char PSSource_HLSL[] = R""(
    Texture2D g_Texture[];
    cbuffer ConstBuffer
    {
        uint Index;
    }
    float4 main() : SV_Target
    {
        return g_Texture[Index].Load(int3(0,0,0));
    }
    )"";

    static constexpr char PSSource_GLSL[] = R""(
    #version 460 core
    #extension GL_EXT_nonuniform_qualifier : require
    #extension GL_EXT_samplerless_texture_functions : require

    uniform texture2D g_Texture[];
    layout(std140) uniform ConstBuffer
    {
        uint Index;
    };
    layout(location=0) out vec4 out_Color;

    void main()
    {
        out_Color = texelFetch(g_Texture[nonuniformEXT(Index)], ivec2(0,0), 0);
    }
    )"";

    ShaderCreateInfo ShaderCI;
    ShaderCI.Desc.ShaderType = SHADER_TYPE_PIXEL;
    ShaderCI.Desc.Name       = ""Invalid Run-Time Array (PSOCreationFailureTest)"";
    ShaderCI.ShaderCompiler  = pEnv->GetDefaultCompiler(ShaderCI.SourceLanguage);
    if (deviceCaps.IsD3DDevice())
    {
        ShaderCI.Source         = PSSource_HLSL;
        ShaderCI.SourceLanguage = SHADER_SOURCE_LANGUAGE_HLSL;
    }
    else
    {
        ShaderCI.Source         = PSSource_GLSL;
        ShaderCI.SourceLanguage = SHADER_SOURCE_LANGUAGE_GLSL_VERBATIM;
    }
    ShaderCI.UseCombinedTextureSamplers = true;
    ShaderCI.CompileFlags               = SHADER_COMPILE_FLAG_ENABLE_UNBOUNDED_ARRAYS;
    RefCntAutoPtr<IShader> pPS;
    pDevice->CreateShader(ShaderCI, &pPS);

    PipelineResourceSignatureDesc PRSDesc;
    PRSDesc.Name = ""PSO Create Failure - Invalid Run-Time Array"";
    PipelineResourceDesc Resources[]{
        {SHADER_TYPE_PIXEL, ""ConstBuffer"", 1, SHADER_RESOURCE_TYPE_CONSTANT_BUFFER, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE},
        {SHADER_TYPE_PIXEL, ""g_Texture"", 2, SHADER_RESOURCE_TYPE_TEXTURE_SRV, SHADER_RESOURCE_VARIABLE_TYPE_MUTABLE}};

    PRSDesc.UseCombinedTextureSamplers = true;
    PRSDesc.Resources                  = Resources;
    PRSDesc.NumResources               = _countof(Resources);

    RefCntAutoPtr<IPipelineResourceSignature> pPRS;
    pDevice->CreatePipelineResourceSignature(PRSDesc, &pPRS);
    ASSERT_NE(pPRS, nullptr);

    IPipelineResourceSignature* ppSignatures[] = {pPRS};

    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Invalid Run-Time Array"")};
    PsoCI.ppResourceSignatures    = ppSignatures;
    PsoCI.ResourceSignaturesCount = _countof(ppSignatures);

    PsoCI.pPS = pPS;

    TestCreatePSOFailure(PsoCI, ""Shader 'Invalid Run-Time Array (PSOCreationFailureTest)' contains resource 'g_Texture' that is a runtime-sized array, ""
                                ""but in the resource signature 'PSO Create Failure - Invalid Run-Time Array' the resource is defined without the PIPELINE_RESOURCE_FLAG_RUNTIME_ARRAY flag."");
}

TEST_F(PSOCreationFailureTest, NonSeparablePrograms_SeparateResources)
{
    if (TestingEnvironment::GetInstance()->GetDevice()->GetDeviceCaps().Features.SeparablePrograms)
    {
        GTEST_SKIP();
    }

    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Non Separable Programs - Separate Resources"")};

    ShaderResourceVariableDesc Variables[] //
        {
            ShaderResourceVariableDesc{SHADER_TYPE_VERTEX, ""g_Texture"", SHADER_RESOURCE_VARIABLE_TYPE_STATIC},
            ShaderResourceVariableDesc{SHADER_TYPE_PIXEL, ""g_Texture"", SHADER_RESOURCE_VARIABLE_TYPE_STATIC} //
        };
    PsoCI.PSODesc.ResourceLayout.Variables    = Variables;
    PsoCI.PSODesc.ResourceLayout.NumVariables = _countof(Variables);
    TestCreatePSOFailure(PsoCI, ""there are separate resources with the name 'g_Texture' in shader stages SHADER_TYPE_PIXEL and SHADER_TYPE_VERTEX"");
}

TEST_F(PSOCreationFailureTest, NonSeparablePrograms_SeparateImmutableSamplers)
{
    if (TestingEnvironment::GetInstance()->GetDevice()->GetDeviceCaps().Features.SeparablePrograms)
    {
        GTEST_SKIP();
    }

    auto PsoCI{GetGraphicsPSOCreateInfo(""PSO Create Failure - Non Separable Programs - Separate Immutable Samplers"")};

    ImmutableSamplerDesc ImtblSamplers[] //
        {
            ImmutableSamplerDesc{SHADER_TYPE_VERTEX, ""g_Texture_sampler"", SamplerDesc{}},
            ImmutableSamplerDesc{SHADER_TYPE_PIXEL, ""g_Texture_sampler"", SamplerDesc{}} //
        };
    PsoCI.PSODesc.ResourceLayout.ImmutableSamplers    = ImtblSamplers;
    PsoCI.PSODesc.ResourceLayout.NumImmutableSamplers = _countof(ImtblSamplers);

    TestCreatePSOFailure(PsoCI, ""there are separate immutable samplers with the name 'g_Texture_sampler' in shader stages SHADER_TYPE_PIXEL and SHADER_TYPE_VERTEX"");
}


} // namespace
",16370,True,3264.0526637249454,median
"[[box-component]]
= Box Component
//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
:page-source: components/camel-box/camel-box-component/src/main/docs/box-component.adoc
:docTitle: Box
:artifactId: camel-box
:description: Upload, download and manage files, folders, groups, collaborations, etc. on box.com.
:since: 2.14
:supportLevel: Stable
:component-header: Both producer and consumer are supported
include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/box.adoc[opts=optional]

*Since Camel {since}*

*{component-header}*

The Box component provides access to all of the Box.com APIs accessible
using https://github.com/box/box-java-sdk/[https://github.com/box/box-java-sdk]. It
allows producing messages to upload and download files, create, edit,
and manage folders, etc. It also supports APIs that allow polling for
updates to user accounts and even changes to enterprise accounts, etc.

Box.com requires the use of OAuth2.0 for all client application
authentication. In order to use camel-box with your account, you'll need
to create a new application within Box.com at
https://developer.box.com/[https://developer.box.com].
The Box application's client id and secret will allow access to Box APIs
which require a current user. A user access token is generated and
managed by the API for an end user. 

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-box</artifactId>
    <version>${camel-version}</version>
</dependency>
----

== Connection Authentication Types

The Box component supports three different types of authenticated connections.

=== Standard Authentication

*Standard Authentication* uses the *OAuth 2.0 three-legged authentication process* to authenticate its connections with Box.com. This type of authentication enables Box *managed users* and *external users* to access, edit, and save their Box content through the Box component.

=== App Enterprise Authentication

*App Enterprise Authentication* uses the *OAuth 2.0 with JSON Web Tokens (JWT)* to authenticate its connections as a *Service Account* for a *Box Application*. This type of authentication enables a service account to access, edit, and save the Box content of its *Box Application* through the Box component.

=== App User Authentication

*App User Authentication* uses the *OAuth 2.0 with JSON Web Tokens (JWT)* to authenticate its connections as an *App User* for a *Box Application*. This type of authentication enables app users to access, edit, and save their Box content in its *Box Application* through the Box component.

== Box Options

// component options: START
The Box component supports 19 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *clientId* (common) | Box application client ID |  | String
| *configuration* (common) | To use the shared configuration |  | BoxConfiguration
| *enterpriseId* (common) | The enterprise ID to use for an App Enterprise. |  | String
| *userId* (common) | The user ID to use for an App User. |  | 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
| *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
| *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
| *httpParams* (advanced) | Custom HTTP params for settings like proxy host |  | Map
| *authenticationType* (authentication) | The type of authentication for connection. Types of Authentication: STANDARD_AUTHENTICATION - OAuth 2.0 (3-legged) SERVER_AUTHENTICATION - OAuth 2.0 with JSON Web Tokens | APP_USER_AUTHENTICATION | String
| *accessTokenCache* (security) | Custom Access Token Cache for storing and retrieving access tokens. |  | IAccessTokenCache
| *clientSecret* (security) | Box application client secret |  | String
| *encryptionAlgorithm* (security) | The type of encryption algorithm for JWT. Supported Algorithms: RSA_SHA_256 RSA_SHA_384 RSA_SHA_512. There are 3 enums and the value can be one of: RSA_SHA_256, RSA_SHA_384, RSA_SHA_512 | RSA_SHA_256 | EncryptionAlgorithm
| *maxCacheEntries* (security) | The maximum number of access tokens in cache. | 100 | int
| *privateKeyFile* (security) | The private key for generating the JWT signature. |  | String
| *privateKeyPassword* (security) | The password for the private key. |  | String
| *publicKeyId* (security) | The ID for public key for validating the JWT signature. |  | String
| *sslContextParameters* (security) | To configure security using SSLContextParameters. |  | SSLContextParameters
| *userName* (security) | Box user name, MUST be provided |  | String
| *userPassword* (security) | Box user password, MUST be provided if authSecureStorage is not set, or returns null on first call |  | String
|===
// component options: END

// endpoint options: START
The Box endpoint is configured using URI syntax:

----
box:apiName/methodName
----

with the following path and query parameters:

=== Path Parameters (2 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *apiName* | *Required* What kind of operation to perform. There are 10 enums and the value can be one of: COLLABORATIONS, COMMENTS, EVENT_LOGS, FILES, FOLDERS, GROUPS, EVENTS, SEARCH, TASKS, USERS |  | BoxApiName
| *methodName* | *Required* What sub operation to use for the selected operation |  | String
|===


=== Query Parameters (19 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *clientId* (common) | Box application client ID |  | String
| *enterpriseId* (common) | The enterprise ID to use for an App Enterprise. |  | String
| *inBody* (common) | Sets the name of a parameter to be passed in the exchange In Body |  | String
| *userId* (common) | The user ID to use for an App User. |  | String
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut |  | ExchangePattern
| *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
| *httpParams* (advanced) | Custom HTTP params for settings like proxy host |  | Map
| *authenticationType* (authentication) | The type of authentication for connection. Types of Authentication: STANDARD_AUTHENTICATION - OAuth 2.0 (3-legged) SERVER_AUTHENTICATION - OAuth 2.0 with JSON Web Tokens | APP_USER_AUTHENTICATION | String
| *accessTokenCache* (security) | Custom Access Token Cache for storing and retrieving access tokens. |  | IAccessTokenCache
| *clientSecret* (security) | Box application client secret |  | String
| *encryptionAlgorithm* (security) | The type of encryption algorithm for JWT. Supported Algorithms: RSA_SHA_256 RSA_SHA_384 RSA_SHA_512. There are 3 enums and the value can be one of: RSA_SHA_256, RSA_SHA_384, RSA_SHA_512 | RSA_SHA_256 | EncryptionAlgorithm
| *maxCacheEntries* (security) | The maximum number of access tokens in cache. | 100 | int
| *privateKeyFile* (security) | The private key for generating the JWT signature. |  | String
| *privateKeyPassword* (security) | The password for the private key. |  | String
| *publicKeyId* (security) | The ID for public key for validating the JWT signature. |  | String
| *sslContextParameters* (security) | To configure security using SSLContextParameters. |  | SSLContextParameters
| *userName* (security) | Box user name, MUST be provided |  | String
| *userPassword* (security) | Box user password, MUST be provided if authSecureStorage is not set, or returns null on first call |  | String
|===




=== API Parameters (10 APIs):

The Box endpoint is an API based component and has additional parameters based on which API name and API method is used.
The API name and API method is located in the endpoint URI as the apiName/methodName path parameters:

----
box:apiName/methodName
----

There are 10 API names as listed in the table below:

[width=""100%"",cols=""2,2,6"",options=""header""]
|===
| API Name | Type | Description
| *collaborations* | Producer | Provides operations to manage Box collaborations
| *comments* | Producer | Provides operations to manage Box comments
| *event-logs* | Producer | Provides operations to read Box enterprise (admin) event logs
| *events* | Consumer | Provides operations to manage Box events
| *files* | Producer | Provides operations to manage Box files
| *folders* | Producer | Provides operations to manage Box folders
| *groups* | Producer | Provides operations to manage Box groups
| *search* | Producer | Provides operations to manage Box searches
| *tasks* | Producer | Provides operations to manage Box tasks
| *users* | Producer | Provides operations to manage Box users
|===

Each API is documented in the following sections to come.


==== API: collaborations

*Only producer is supported*




The collaborations API has 6 method(s) which is represented by the following method signatures
(an API method may have multiple signatures due to overloading):

[source,java]
----

com.box.sdk.BoxCollaboration addFolderCollaboration(String folderId, com.box.sdk.BoxCollaborator collaborator, com.box.sdk.BoxCollaboration.Role role);

com.box.sdk.BoxCollaboration addFolderCollaborationByEmail(String folderId, String email, com.box.sdk.BoxCollaboration.Role role);

void deleteCollaboration(String collaborationId);

com.box.sdk.BoxCollaboration.Info getCollaborationInfo(String collaborationId);

java.util.Collection<com.box.sdk.BoxCollaboration.Info> getFolderCollaborations(String folderId);

com.box.sdk.BoxCollaboration updateCollaborationInfo(String collaborationId, com.box.sdk.BoxCollaboration.Info info);

----

The collaborations API is defined in the syntax as follows:

----
box:collaborations/methodName?[parameters]
----

The 6 method(s) is listed in the table below.
(API methods can have a shorthand alias name which can be used in the syntax instead of the name)

[width=""100%"",cols=""2,2,6"",options=""header""]
|===
| Method | Alias | Description
| *addFolderCollaboration* | add | Add a collaboration to this folder
| *addFolderCollaborationByEmail* | addByEmail | Add a collaboration to this folder
| *deleteCollaboration* | delete | Delete collaboration
| *getCollaborationInfo* | info | Get collaboration information
| *getFolderCollaborations* | collaborations | Get information about all of the collaborations for folder
| *updateCollaborationInfo* | updateInfo | Update collaboration information
|===

The collaborations API method(s) has the following set of parameters listed in the table below:
[width=""100%"",cols=""2,2,4,2"",options=""header""]
|===
| Method | Parameter | Description | Type
| addFolderCollaboration | *collaborator* |  The collaborator to add | BoxCollaborator
| addFolderCollaboration | *folderId* |  The id of folder to add collaboration to | String
| addFolderCollaboration | *role* |  The role of the collaborator | Role
| addFolderCollaborationByEmail | *email* |  The email address of the collaborator to add | String
| addFolderCollaborationByEmail | *folderId* |  The id of folder to add collaboration to | String
| addFolderCollaborationByEmail | *role* |  The role of the collaborator | Role
| deleteCollaboration | *collaborationId* |  The id of comment to change | String
| getCollaborationInfo | *collaborationId* |  The id of collaboration | String
| getFolderCollaborations | *folderId* |  The id of folder to get collaborations information on | String
| updateCollaborationInfo | *collaborationId* |  The id of collaboration | String
| updateCollaborationInfo | *info* |  Collaboration information to update | Info
|===

In addition to the parameters above, the collaborations API can also use from the 19 endpoint query option
which is listed in the _Query Parameters_ section.

Any of the parameters can be provided in either the endpoint URI, or dynamically in a message header.
The message header name must be of the format `CamelBox.parameter`.
The `inBody` parameter overrides message header, i.e. the endpoint parameter `inBody=myParameterNameHere`
would override a `CamelBox.myParameterNameHere` header.



==== API: comments

*Only producer is supported*




The comments API has 6 method(s) which is represented by the following method signatures
(an API method may have multiple signatures due to overloading):

[source,java]
----

com.box.sdk.BoxFile addFileComment(String fileId, String message);

com.box.sdk.BoxComment changeCommentMessage(String commentId, String message);

void deleteComment(String commentId);

com.box.sdk.BoxComment.Info getCommentInfo(String commentId);

java.util.List<com.box.sdk.BoxComment.Info> getFileComments(String fileId);

com.box.sdk.BoxComment replyToComment(String commentId, String message);

----

The comments API is defined in the syntax as follows:

----
box:comments/methodName?[parameters]
----

The 6 method(s) is listed in the table below.
(API methods can have a shorthand alias name which can be used in the syntax instead of the name)

[width=""100%"",cols=""2,2,6"",options=""header""]
|===
| Method | Alias | Description
| *addFileComment* | add | Add comment to file
| *changeCommentMessage* | updateMessage | Change comment message
| *deleteComment* | delete | Delete comment
| *getCommentInfo* | info | Get comment information
| *getFileComments* | comments | Get a list of any comments on this file
| *replyToComment* | reply | Reply to a comment
|===

The comments API method(s) has the following set of parameters listed in the table below:
[width=""100%"",cols=""2,2,4,2"",options=""header""]
|===
| Method | Parameter | Description | Type
| addFileComment | *fileId* |  The id of file | String
| addFileComment | *message* |  The comment's message | String
| changeCommentMessage | *commentId* |  The id of comment to change | String
| changeCommentMessage | *message* |  The new message for the comment | String
| deleteComment | *commentId* |  The id of comment to delete | String
| getCommentInfo | *commentId* |  The id of comment | String
| getFileComments | *fileId* |  The id of file | String
| replyToComment | *commentId* |  The id of comment to reply to | String
| replyToComment | *message* |  The message for the reply | String
|===

In addition to the parameters above, the comments API can also use from the 19 endpoint query option
which is listed in the _Query Parameters_ section.

Any of the parameters can be provided in either the endpoint URI, or dynamically in a message header.
The message header name must be of the format `CamelBox.parameter`.
The `inBody` parameter overrides message header, i.e. the endpoint parameter `inBody=myParameterNameHere`
would override a `CamelBox.myParameterNameHere` header.



==== API: event-logs

*Only producer is supported*




The event-logs API has 1 method(s) which is represented by the following method signatures
(an API method may have multiple signatures due to overloading):

[source,java]
----

java.util.List<com.box.sdk.BoxEvent> getEnterpriseEvents(String position, java.util.Date after, java.util.Date before, com.box.sdk.BoxEvent.Type[] types);

----

The event-logs API is defined in the syntax as follows:

----
box:event-logs/methodName?[parameters]
----

The 1 method(s) is listed in the table below.
(API methods can have a shorthand alias name which can be used in the syntax instead of the name)

[width=""100%"",cols=""2,2,6"",options=""header""]
|===
| Method | Alias | Description
| *getEnterpriseEvents* | events | Create an event stream with optional starting initial position and add listener that will be notified when an event is received
|===

The event-logs API method(s) has the following set of parameters listed in the table below:
[width=""100%"",cols=""2,2,4,2"",options=""header""]
|===
| Method | Parameter | Description | Type
| getEnterpriseEvents | *after* |  The lower bound on the timestamp of the events returned | Date
| getEnterpriseEvents | *before* |  The upper bound on the timestamp of the events returned | Date
| getEnterpriseEvents | *position* | *Optional*  The starting position of the event stream. May be null in which case all events within bounds returned. | String
| getEnterpriseEvents | *types* | *Optional*  An optional list of event types to filter by | Type[]
|===

In addition to the parameters above, the event-logs API can also use from the 19 endpoint query option
which is listed in the _Query Parameters_ section.

Any of the parameters can be provided in either the endpoint URI, or dynamically in a message header.
The message header name must be of the format `CamelBox.parameter`.
The `inBody` parameter overrides message header, i.e. the endpoint parameter `inBody=myParameterNameHere`
would override a `CamelBox.myParameterNameHere` header.



==== API: events

*Only consumer is supported*




The events API has 1 method(s) which is represented by the following method signatures
(an API method may have multiple signatures due to overloading):

[source,java]
----

void listen(com.box.sdk.EventListener listener, Long startingPosition);

----

The events API is defined in the syntax as follows:

----
box:events/methodName?[parameters]
----

The 1 method(s) is listed in the table below.
(API methods can have a shorthand alias name which can be used in the syntax instead of the name)

[width=""100%"",cols=""2,2,6"",options=""header""]
|===
| Method | Alias | Description
| *listen* |  | Create an event stream with optional starting initial position and add listener that will be notified when an event is received
|===

The events API method(s) has the following set of parameters listed in the table below:
[width=""100%"",cols=""2,2,4,2"",options=""header""]
|===
| Method | Parameter | Description | Type
| listen | *startingPosition* | *Optional*  The starting position of the event stream | Long
|===

In addition to the parameters above, the events API can also use from the 19 endpoint query option
which is listed in the _Query Parameters_ section.

Any of the parameters can be provided in either the endpoint URI, or dynamically in a message header.
The message header name must be of the format `CamelBox.parameter`.
The `inBody` parameter overrides message header, i.e. the endpoint parameter `inBody=myParameterNameHere`
would override a `CamelBox.myParameterNameHere` header.



==== API: files

*Only producer is supported*




The files API has 22 method(s) which is represented by the following method signatures
(an API method may have multiple signatures due to overloading):

[source,java]
----

void checkUpload(String fileName, String parentFolderId, Long size);

com.box.sdk.BoxFile copyFile(String fileId, String destinationFolderId, String newName);

com.box.sdk.Metadata createFileMetadata(String fileId, com.box.sdk.Metadata metadata, String typeName);

com.box.sdk.BoxSharedLink createFileSharedLink(String fileId, com.box.sdk.BoxSharedLink.Access access, java.util.Date unshareDate, com.box.sdk.BoxSharedLink.Permissions permissions);

void deleteFile(String fileId);

void deleteFileMetadata(String fileId);

void deleteFileVersion(String fileId, Integer version);

java.io.OutputStream downloadFile(String fileId, java.io.OutputStream output, Long rangeStart, Long rangeEnd, com.box.sdk.ProgressListener listener);

java.io.OutputStream downloadPreviousFileVersion(String fileId, Integer version, java.io.OutputStream output, com.box.sdk.ProgressListener listener);

java.net.URL getDownloadURL(String fileId);

com.box.sdk.BoxFile.Info getFileInfo(String fileId, String[] fields);

com.box.sdk.Metadata getFileMetadata(String fileId, String typeName);

java.net.URL getFilePreviewLink(String fileId);

byte[] getFileThumbnail(String fileId, com.box.sdk.BoxFile.ThumbnailFileType fileType, Integer minWidth, Integer minHeight, Integer maxWidth, Integer maxHeight);

java.util.Collection<com.box.sdk.BoxFileVersion> getFileVersions(String fileId);

com.box.sdk.BoxFile moveFile(String fileId, String destinationFolderId, String newName);

com.box.sdk.BoxFileVersion promoteFileVersion(String fileId, Integer version);

com.box.sdk.BoxFile renameFile(String fileId, String newFileName);

com.box.sdk.BoxFile updateFileInfo(String fileId, com.box.sdk.BoxFile.Info info);

com.box.sdk.Metadata updateFileMetadata(String fileId, com.box.sdk.Metadata metadata);

com.box.sdk.BoxFile uploadFile(String parentFolderId, java.io.InputStream content, String fileName, java.util.Date created, java.util.Date modified, Long size, Boolean check, com.box.sdk.ProgressListener listener);

com.box.sdk.BoxFile uploadNewFileVersion(String fileId, java.io.InputStream fileContent, java.util.Date modified, Long fileSize, com.box.sdk.ProgressListener listener);

----

The files API is defined in the syntax as follows:

----
box:files/methodName?[parameters]
----

The 22 method(s) is listed in the table below.
(API methods can have a shorthand alias name which can be used in the syntax instead of the name)

[width=""100%"",cols=""2,2,6"",options=""header""]
|===
| Method | Alias | Description
| *checkUpload* | canUpload | Does a pre-verification before upload, to check if the filename already exists or if there is permission to upload
| *copyFile* | copy | Copy file to destination folder while optionally giving it a new name
| *createFileMetadata* | createMetadata | Create metadata for file in either the global properties template or the specified template type
| *createFileSharedLink* | link | Create a shared link to file
| *deleteFile* | delete | Delete the file
| *deleteFileMetadata* | deleteMetadata | Delete the file properties metadata
| *deleteFileVersion* | deleteVersion | Delete a file version
| *downloadFile* | download | Download a file
| *downloadPreviousFileVersion* | downloadVersion | Download a previous version of file
| *getDownloadURL* | url | Get an expiring URL for downloading a file directly from Box
| *getFileInfo* | info | Get file information
| *getFileMetadata* | metadata | Gets the file properties metadata
| *getFilePreviewLink* |  | Get an expiring URL for creating an embedded preview session
| *getFileThumbnail* | thumbnail | Retrieves a thumbnail, or smaller image representation, of this file
| *getFileVersions* | versions | Get any previous versions of file
| *moveFile* | move | Move file to destination folder while optionally giving it a new name
| *promoteFileVersion* | promoteVersion | Promote a previous version of file
| *renameFile* | rename | Rename file giving it the name newName
| *updateFileInfo* | updateInfo | Update file information
| *updateFileMetadata* | updateMetadata | Update the file properties metadata
| *uploadFile* | upload | Upload a new file to parent folder
| *uploadNewFileVersion* | uploadVersion | Upload a new version of file
|===

The files API method(s) has the following set of parameters listed in the table below:
[width=""100%"",cols=""2,2,4,2"",options=""header""]
|===
| Method | Parameter | Description | Type
| checkUpload | *fileName* |  The name to give the uploaded file | String
| checkUpload | *parentFolderId* |  The id of parent folder | String
| checkUpload | *size* | *Optional*  The size of the file's content used for monitoring the upload's progress | Long
| copyFile | *destinationFolderId* |  The id of the destination folder | String
| copyFile | *fileId* |  The id of file to copy | String
| copyFile | *newName* | *Optional*  The new name for copied file; if newName is null, the copied file has same name as the original. | String
| createFileMetadata | *fileId* |  The id of the file to create metadata for | String
| createFileMetadata | *metadata* |  The new metadata values | Metadata
| createFileMetadata | *typeName* | *Optional*  The metadata template type name; if null the global properties template type is used. | String
| createFileSharedLink | *access* |  The access level of the shared link | Access
| createFileSharedLink | *fileId* |  The id of the file to create shared link on | String
| createFileSharedLink | *permissions* | *Optional*  The permissions of the created link; if permissions is null then the created shared link is create with default permissions. | Permissions
| createFileSharedLink | *unshareDate* | *Optional*  The date and time at which time the created shared link will expire; if unsharedDate is null then a non-expiring link is created. | Date
| deleteFile | *fileId* |  The id of file to delete | String
| deleteFileMetadata | *fileId* |  The id of file to delete | String
| deleteFileVersion | *fileId* |  The id of file with version to delete | String
| deleteFileVersion | *version* |  The version of file to delete; initial version of file has value of 0, second version of file is 1 and so on. | Integer
| downloadFile | *fileId* |  The id of file | String
| downloadFile | *listener* | *Optional*  A listener for monitoring the download's progress; if null the download's progress will not be monitored. | ProgressListener
| downloadFile | *output* |  The stream to which the file contents will be written | OutputStream
| downloadFile | *rangeEnd* | *Optional*  The byte offset in file at which to stop the download; if null the entire contents of file will be downloaded. | Long
| downloadFile | *rangeStart* | *Optional*  The byte offset in file at which to start the download; if null the entire contents of file will be downloaded. | Long
| downloadPreviousFileVersion | *fileId* |  The id of file | String
| downloadPreviousFileVersion | *listener* | *Optional*  A listener for monitoring the download's progress; if null the download's progress will not be monitored. | ProgressListener
| downloadPreviousFileVersion | *output* |  The stream to which the version contents will be written | OutputStream
| downloadPreviousFileVersion | *version* |  The version of file to download; initial version of file has value of 0, second version of file is 1 and so on. | Integer
| getDownloadURL | *fileId* |  The id of file | String
| getFileInfo | *fields* | *Optional*  The information fields to retrieve; if null all information fields are retrieved. | String[]
| getFileInfo | *fileId* |  The id of file | String
| getFileMetadata | *fileId* |  The id of the file to retrieve metadata for | String
| getFileMetadata | *typeName* | *Optional*  The metadata template type name; if null the global properties template type is used. | String
| getFilePreviewLink | *fileId* |  The id of the file to get preview link on | String
| getFileThumbnail | *fileId* |  The id of the file to get thumbnail | String
| getFileThumbnail | *fileType* |  Either PNG of JPG | ThumbnailFileType
| getFileThumbnail | *maxHeight* |  Maximum height | Integer
| getFileThumbnail | *maxWidth* |  Maximum width | Integer
| getFileThumbnail | *minHeight* |  Minimum height | Integer
| getFileThumbnail | *minWidth* |  Minimum width | Integer
| getFileVersions | *fileId* |  The id of file | String
| moveFile | *destinationFolderId* |  The id of the destination folder | String
| moveFile | *fileId* |  The id of file to move | String
| moveFile | *newName* | *Optional*  The new name of moved file; if newName is null, the moved file has same name as the original. | String
| promoteFileVersion | *fileId* |  The id of file | String
| promoteFileVersion | *version* |  The version of file to promote; initial version of file has value of 0, second version of file is 1 and so on. | Integer
| renameFile | *fileId* |  The id of file to rename | String
| renameFile | *newFileName* |  The new name of file | String
| updateFileInfo | *fileId* |  The id of file to update | String
| updateFileInfo | *info* |  The updated information | Info
| updateFileMetadata | *fileId* |  The id of file to delete | String
| updateFileMetadata | *metadata* |  The new metadata values | Metadata
| uploadFile | *check* | *Optional*  If the file name is already used, call the uploadNewVersion instead. | Boolean
| uploadFile | *content* |  A stream containing contents of the file to upload | InputStream
| uploadFile | *created* | *Optional*  The content created date that will be given to the uploaded file | Date
| uploadFile | *fileName* |  The name to give the uploaded file | String
| uploadFile | *listener* | *Optional*  A listener for monitoring the upload's progress | ProgressListener
| uploadFile | *modified* | *Optional*  The content modified date that will be given to the uploaded file | Date
| uploadFile | *parentFolderId* |  The id of parent folder | String
| uploadFile | *size* | *Optional*  The size of the file's content used for monitoring the upload's progress | Long
| uploadNewFileVersion | *fileContent* |  A stream containing contents of the file to upload | InputStream
| uploadNewFileVersion | *fileId* |  The id of file | String
| uploadNewFileVersion | *fileSize* | *Optional*  The size of the file's content used for monitoring the upload's progress | Long
| uploadNewFileVersion | *listener* | *Optional*  A listener for monitoring the upload's progress | ProgressListener
| uploadNewFileVersion | *modified* | *Optional*  The content modified date that will be given to the uploaded file | Date
|===

In addition to the parameters above, the files API can also use from the 19 endpoint query option
which is listed in the _Query Parameters_ section.

Any of the parameters can be provided in either the endpoint URI, or dynamically in a message header.
The message header name must be of the format `CamelBox.parameter`.
The `inBody` parameter overrides message header, i.e. the endpoint parameter `inBody=myParameterNameHere`
would override a `CamelBox.myParameterNameHere` header.



==== API: folders

*Only producer is supported*




The folders API has 10 method(s) which is represented by the following method signatures
(an API method may have multiple signatures due to overloading):

[source,java]
----

com.box.sdk.BoxFolder copyFolder(String folderId, String destinationFolderId, String newName);

com.box.sdk.BoxFolder createFolder(String parentFolderId, String folderName);

com.box.sdk.BoxFolder createFolder(String parentFolderId, String[] path);

com.box.sdk.BoxSharedLink createFolderSharedLink(String folderId, com.box.sdk.BoxSharedLink.Access access, java.util.Date unshareDate, com.box.sdk.BoxSharedLink.Permissions permissions);

void deleteFolder(String folderId);

com.box.sdk.BoxFolder getFolder(String[] path);

com.box.sdk.BoxFolder.Info getFolderInfo(String folderId, String[] fields);

java.util.Collection<com.box.sdk.BoxItem.Info> getFolderItems(String folderId, Long offset, Long limit, String[] fields);

com.box.sdk.BoxFolder moveFolder(String folderId, String destinationFolderId, String newName);

com.box.sdk.BoxFolder renameFolder(String folderId, String newFolderName);

com.box.sdk.BoxFolder updateFolderInfo(String folderId, com.box.sdk.BoxFolder.Info info);

----

The folders API is defined in the syntax as follows:

----
box:folders/methodName?[parameters]
----

The 10 method(s) is listed in the table below.
(API methods can have a shorthand alias name which can be used in the syntax instead of the name)

[width=""100%"",cols=""2,2,6"",options=""header""]
|===
| Method | Alias | Description
| *copyFolder* | copy | Copy folder to destination folder while optionally giving it a new name
| *createFolder* | create | Create a folder specified by path from parent folder with given parentFolderId, creating intermediate directories as required
| *createFolderSharedLink* | link | Create a shared link to folder
| *deleteFolder* | delete | Delete folder
| *getFolder* | folder | Return the Box folder referenced by path
| *getFolderInfo* | info | Get folder information
| *getFolderItems* | items | Returns a specific range of child items in folder and specifies which fields of each item to retrieve
| *moveFolder* | move | Move folder to destination folder while optionally giving it a new name
| *renameFolder* | rename | Rename folder giving it the name newName
| *updateFolderInfo* | updateInfo | Update folder information
|===

The folders API method(s) has the following set of parameters listed in the table below:
[width=""100%"",cols=""2,2,4,2"",options=""header""]
|===
| Method | Parameter | Description | Type
| copyFolder | *destinationFolderId* |  The id of the destination folder | String
| copyFolder | *folderId* |  The id of folder to copy | String
| copyFolder | *newName* | *Optional*  The new name for copied folder; if newName is null, the copied folder has same name as the original. | String
| createFolder | *folderName* |  The name of created folder | String
| createFolder | *parentFolderId* |  The id of parent folder | String
| createFolder | *path* |  Sequence of Box folder names from parent folder to returned folder | String[]
| createFolderSharedLink | *access* |  The access level of the shared link | Access
| createFolderSharedLink | *folderId* |  The id of folder to create shared link on | String
| createFolderSharedLink | *permissions* |  The permissions of the created link; if permissions is null then the created shared link is create with default permissions. | Permissions
| createFolderSharedLink | *unshareDate* |  The date and time at which time the created shared link will expire; if unsharedDate is null then a non-expiring link is created. | Date
| deleteFolder | *folderId* |  The id of folder to delete | String
| getFolder | *path* |  Sequence of Box folder names from root folder to returned folder | String[]
| getFolderInfo | *fields* | *Optional*  The information fields to retrieve; if null all information fields are retrieved. | String[]
| getFolderInfo | *folderId* |  The id of folder | String
| getFolderItems | *fields* | *Optional*  The item fields to retrieve for each child item; if null all item fields are retrieved. | String[]
| getFolderItems | *folderId* |  The id of folder | String
| getFolderItems | *limit* | *Optional*  The maximum number of children to retrieve after the offset; if null all child items are retrieved. | Long
| getFolderItems | *offset* | *Optional*  The index of first child item to retrieve; if null all child items are retrieved. | Long
| moveFolder | *destinationFolderId* |  The id of the destination folder | String
| moveFolder | *folderId* |  The id of folder to move | String
| moveFolder | *newName* | *Optional*  The new name of moved folder; if newName is null, the moved folder has same name as the original. | String
| renameFolder | *folderId* |  The id of folder to rename | String
| renameFolder | *newFolderName* |  The new name of folder | String
| updateFolderInfo | *folderId* |  The id of folder to update | String
| updateFolderInfo | *info* |  The updated information | Info
|===

In addition to the parameters above, the folders API can also use from the 19 endpoint query option
which is listed in the _Query Parameters_ section.

Any of the parameters can be provided in either the endpoint URI, or dynamically in a message header.
The message header name must be of the format `CamelBox.parameter`.
The `inBody` parameter overrides message header, i.e. the endpoint parameter `inBody=myParameterNameHere`
would override a `CamelBox.myParameterNameHere` header.



==== API: groups

*Only producer is supported*




The groups API has 9 method(s) which is represented by the following method signatures
(an API method may have multiple signatures due to overloading):

[source,java]
----

com.box.sdk.BoxGroupMembership addGroupMembership(String groupId, String userId, com.box.sdk.BoxGroupMembership.Role role);

com.box.sdk.BoxGroup createGroup(String name, String provenance, String externalSyncIdentifier, String description, String invitabilityLevel, String memberViewabilityLevel);

void deleteGroup(String groupId);

void deleteGroupMembership(String groupMembershipId);

com.box.sdk.BoxGroup.Info getGroupInfo(String groupId);

com.box.sdk.BoxGroupMembership.Info getGroupMembershipInfo(String groupMembershipId);

java.util.Collection<com.box.sdk.BoxGroupMembership.Info> getGroupMemberships(String groupId);

com.box.sdk.BoxGroup updateGroupInfo(String groupId, com.box.sdk.BoxGroup.Info groupInfo);

com.box.sdk.BoxGroupMembership updateGroupMembershipInfo(String groupMembershipId, com.box.sdk.BoxGroupMembership.Info info);

----

The groups API is defined in the syntax as follows:

----
box:groups/methodName?[parameters]
----

The 9 method(s) is listed in the table below.
(API methods can have a shorthand alias name which can be used in the syntax instead of the name)

[width=""100%"",cols=""2,2,6"",options=""header""]
|===
| Method | Alias | Description
| *addGroupMembership* | addMembership | Add a member to group with the specified role
| *createGroup* | create | Create a new group with a specified name and optional additional parameters
| *deleteGroup* | delete | Delete group
| *deleteGroupMembership* | deleteMembership | Delete group membership
| *getGroupInfo* | info | Get group information
| *getGroupMembershipInfo* | membershipInfo | Get group membership information
| *getGroupMemberships* | memberships | Get information about all of the group memberships for this group
| *updateGroupInfo* |  | Update group information
| *updateGroupMembershipInfo* | updateMembershipInfo | Update group membership information
|===

The groups API method(s) has the following set of parameters listed in the table below:
[width=""100%"",cols=""2,2,4,2"",options=""header""]
|===
| Method | Parameter | Description | Type
| addGroupMembership | *groupId* |  The id of group | String
| addGroupMembership | *role* | *Optional*  The role of the user in this group. Can be null to assign the default role. | Role
| addGroupMembership | *userId* |  The id of user to be added to group | String
| createGroup | *description* | *Optional*  The description of the new group | String
| createGroup | *externalSyncIdentifier* | *Optional*  The external_sync_identifier of the new group | String
| createGroup | *invitabilityLevel* | *Optional*  The invitibility_level of the new group | String
| createGroup | *memberViewabilityLevel* | *Optional*  The member_viewability_level of the new group | String
| createGroup | *name* |  The name of the new group | String
| createGroup | *provenance* | *Optional*  The provenance of the new group | String
| deleteGroup | *groupId* |  The id of group to delete | String
| deleteGroupMembership | *groupMembershipId* |  The id of group membership to delete | String
| getGroupInfo | *groupId* |  The id of group | String
| getGroupMembershipInfo | *groupMembershipId* |  The id of group membership | String
| getGroupMemberships | *groupId* |  The id of group | String
| updateGroupInfo | *groupId* |  The id of group to update | String
| updateGroupInfo | *groupInfo* |  The updated information | Info
| updateGroupMembershipInfo | *groupMembershipId* |  The id of group membership to update | String
| updateGroupMembershipInfo | *info* |  The updated information | Info
|===

In addition to the parameters above, the groups API can also use from the 19 endpoint query option
which is listed in the _Query Parameters_ section.

Any of the parameters can be provided in either the endpoint URI, or dynamically in a message header.
The message header name must be of the format `CamelBox.parameter`.
The `inBody` parameter overrides message header, i.e. the endpoint parameter `inBody=myParameterNameHere`
would override a `CamelBox.myParameterNameHere` header.



==== API: search

*Only producer is supported*




The search API has 1 method(s) which is represented by the following method signatures
(an API method may have multiple signatures due to overloading):

[source,java]
----

java.util.Collection<com.box.sdk.BoxItem> searchFolder(String folderId, String query);

----

The search API is defined in the syntax as follows:

----
box:search/methodName?[parameters]
----

The 1 method(s) is listed in the table below.
(API methods can have a shorthand alias name which can be used in the syntax instead of the name)

[width=""100%"",cols=""2,2,6"",options=""header""]
|===
| Method | Alias | Description
| *searchFolder* | search | Search folder and all descendant folders using the given query
|===

The search API method(s) has the following set of parameters listed in the table below:
[width=""100%"",cols=""2,2,4,2"",options=""header""]
|===
| Method | Parameter | Description | Type
| searchFolder | *folderId* |  The id of folder searched | String
| searchFolder | *query* |  The search query | String
|===

In addition to the parameters above, the search API can also use from the 19 endpoint query option
which is listed in the _Query Parameters_ section.

Any of the parameters can be provided in either the endpoint URI, or dynamically in a message header.
The message header name must be of the format `CamelBox.parameter`.
The `inBody` parameter overrides message header, i.e. the endpoint parameter `inBody=myParameterNameHere`
would override a `CamelBox.myParameterNameHere` header.



==== API: tasks

*Only producer is supported*




The tasks API has 9 method(s) which is represented by the following method signatures
(an API method may have multiple signatures due to overloading):

[source,java]
----

com.box.sdk.BoxTask addAssignmentToTask(String taskId, com.box.sdk.BoxUser assignTo);

com.box.sdk.BoxTask addFileTask(String fileId, com.box.sdk.BoxTask.Action action, java.util.Date dueAt, String message);

void deleteTask(String taskId);

void deleteTaskAssignment(String taskAssignmentId);

java.util.List<com.box.sdk.BoxTask.Info> getFileTasks(String fileId);

com.box.sdk.BoxTaskAssignment.Info getTaskAssignmentInfo(String taskAssignmentId);

java.util.List<com.box.sdk.BoxTaskAssignment.Info> getTaskAssignments(String taskId);

com.box.sdk.BoxTask.Info getTaskInfo(String taskId);

com.box.sdk.BoxTask updateTaskInfo(String taskId, com.box.sdk.BoxTask.Info info);

----

The tasks API is defined in the syntax as follows:

----
box:tasks/methodName?[parameters]
----

The 9 method(s) is listed in the table below.
(API methods can have a shorthand alias name which can be used in the syntax instead of the name)

[width=""100%"",cols=""2,2,6"",options=""header""]
|===
| Method | Alias | Description
| *addAssignmentToTask* | addAssignment | Add assignment for task
| *addFileTask* | add | Add task to file
| *deleteTask* | delete | Delete task
| *deleteTaskAssignment* | deleteAssignment | Delete task assignment
| *getFileTasks* | tasks | Get a list of any tasks on file
| *getTaskAssignmentInfo* | assignmentInfo | Get task assignment information
| *getTaskAssignments* | assignments | Get a list of any assignments for task
| *getTaskInfo* | info | Get task information
| *updateTaskInfo* | updateInfo | Update task information
|===

The tasks API method(s) has the following set of parameters listed in the table below:
[width=""100%"",cols=""2,2,4,2"",options=""header""]
|===
| Method | Parameter | Description | Type
| addAssignmentToTask | *assignTo* |  The user to assign to task | BoxUser
| addAssignmentToTask | *taskId* |  The id of task to add assignment for | String
| addFileTask | *action* |  The action the task assignee will be prompted to do | Action
| addFileTask | *dueAt* |  The day at which this task is due | Date
| addFileTask | *fileId* |  The id of file to add task to | String
| addFileTask | *message* | *Optional*  An optional message to include with the task | String
| deleteTask | *taskId* |  The id of task to delete | String
| deleteTaskAssignment | *taskAssignmentId* |  The id of task assignment to delete | String
| getFileTasks | *fileId* |  The id of file | String
| getTaskAssignmentInfo | *taskAssignmentId* |  The id of task assignment | String
| getTaskAssignments | *taskId* |  The id of task | String
| getTaskInfo | *taskId* |  The id of task | String
| updateTaskInfo | *info* |  The updated information | Info
| updateTaskInfo | *taskId* |  The id of task | String
|===

In addition to the parameters above, the tasks API can also use from the 19 endpoint query option
which is listed in the _Query Parameters_ section.

Any of the parameters can be provided in either the endpoint URI, or dynamically in a message header.
The message header name must be of the format `CamelBox.parameter`.
The `inBody` parameter overrides message header, i.e. the endpoint parameter `inBody=myParameterNameHere`
would override a `CamelBox.myParameterNameHere` header.



==== API: users

*Only producer is supported*




The users API has 10 method(s) which is represented by the following method signatures
(an API method may have multiple signatures due to overloading):

[source,java]
----

com.box.sdk.EmailAlias addUserEmailAlias(String userId, String email);

com.box.sdk.BoxUser createAppUser(String name, com.box.sdk.CreateUserParams params);

com.box.sdk.BoxUser createEnterpriseUser(String login, String name, com.box.sdk.CreateUserParams params);

void deleteUser(String userId, boolean notifyUser, boolean force);

void deleteUserEmailAlias(String userId, String emailAliasId);

java.util.List<com.box.sdk.BoxUser.Info> getAllEnterpriseOrExternalUsers(String filterTerm, String[] fields);

java.util.Collection<com.box.sdk.EmailAlias> getUserEmailAlias(String userId);

com.box.sdk.BoxUser.Info getUserInfo(String userId);

com.box.sdk.BoxFolder.Info moveFolderToUser(String userId, String sourceUserId);

com.box.sdk.BoxUser updateUserInfo(String userId, com.box.sdk.BoxUser.Info info);

----

The users API is defined in the syntax as follows:

----
box:users/methodName?[parameters]
----

The 10 method(s) is listed in the table below.
(API methods can have a shorthand alias name which can be used in the syntax instead of the name)

[width=""100%"",cols=""2,2,6"",options=""header""]
|===
| Method | Alias | Description
| *addUserEmailAlias* | addEmailAlias | Add a new email alias to user's account
| *createAppUser* | create | Provision a new app user in an enterprise with additional user information using Box Developer Edition
| *createEnterpriseUser* | create | Provision a new user in an enterprise with additional user information
| *deleteUser* | delete | Delete user from an enterprise account
| *deleteUserEmailAlias* | deleteEmailAlias | Delete an email alias from user's account
| *getAllEnterpriseOrExternalUsers* | users | Get any managed users that match the filter term as well as any external users that match the filter term
| *getUserEmailAlias* | emailAlias | Get a collection of all the email aliases for user
| *getUserInfo* | info | Get user information
| *moveFolderToUser* |  | Move root folder for specified user to current user
| *updateUserInfo* | updateInfo | Update user information
|===

The users API method(s) has the following set of parameters listed in the table below:
[width=""100%"",cols=""2,2,4,2"",options=""header""]
|===
| Method | Parameter | Description | Type
| addUserEmailAlias | *email* |  The email address to add as an alias | String
| addUserEmailAlias | *userId* |  The id of user | String
| createAppUser | *name* |  The name of the user | String
| createAppUser | *params* | *Optional*  Additional user information | CreateUserParams
| createEnterpriseUser | *login* |  The email address the user will use to login | String
| createEnterpriseUser | *name* |  The name of the user | String
| createEnterpriseUser | *params* | *Optional*  Additional user information | CreateUserParams
| deleteUser | *force* |  Whether or not this user should be deleted even if they still own files | Boolean
| deleteUser | *notifyUser* |  Whether or not to send an email notification to the user that their account has been deleted | Boolean
| deleteUser | *userId* |  The id of user to delete | String
| deleteUserEmailAlias | *emailAliasId* |  The id of the email alias to delete | String
| deleteUserEmailAlias | *userId* |  The id of user | String
| getAllEnterpriseOrExternalUsers | *fields* | *Optional*  The fields to retrieve. Leave this out for the standard fields. | String[]
| getAllEnterpriseOrExternalUsers | *filterTerm* | *Optional*  The filter term to lookup users by (login for external, login or name for managed); if null all managed users are returned. | String
| getUserEmailAlias | *userId* |  The id of user | String
| getUserInfo | *userId* |  The id of user | String
| moveFolderToUser | *sourceUserId* |  The user id of the user whose files will be the source for this operation | String
| moveFolderToUser | *userId* |  The id of user | String
| updateUserInfo | *info* |  The updated information | Info
| updateUserInfo | *userId* |  The id of user to update | String
|===

In addition to the parameters above, the users API can also use from the 19 endpoint query option
which is listed in the _Query Parameters_ section.

Any of the parameters can be provided in either the endpoint URI, or dynamically in a message header.
The message header name must be of the format `CamelBox.parameter`.
The `inBody` parameter overrides message header, i.e. the endpoint parameter `inBody=myParameterNameHere`
would override a `CamelBox.myParameterNameHere` header.
// endpoint options: END

== Samples

The following route uploads new files to the user's root folder:

[source,java]
----
from(""file:..."")
    .to(""box://files/upload/inBody=fileUploadRequest"");
----

The following route polls user's account for updates:

[source,java]
----
from(""box://events/listen?startingPosition=-1"")
    .to(""bean:blah"");
----

The following route uses a producer with dynamic header options. The
*fileId* property has the Box file id and the *output* property has 
the output stream of the file contents, so they are assigned to the
*CamelBox.fileId* header and *CamelBox.output* header respectively
as follows:

[source,java]
----
from(""direct:foo"")
    .setHeader(""CamelBox.fileId"", header(""fileId""))
    .setHeader(""CamelBox.output"", header(""output""))
    .to(""box://files/download"")
    .to(""file://..."");
----

=== More information

See more details at the Box API reference: https://developer.box.com/reference

include::camel-spring-boot::page$box-starter.adoc[]
",12326,True,2565.2807709899607,median
"---
title: ""FreeBSD/sparc64 5.4-RELEASE Installation Instructions""
sidenav: download
---

++++


<h3 class=""CORPAUTHOR"">The FreeBSD Project</h3>

<p class=""COPYRIGHT"">Copyright &copy; 2000, 2001, 2002, 2003, 2004 The FreeBSD
Documentation Project</p>

<hr />
</div>

<blockquote class=""ABSTRACT"">
<div class=""ABSTRACT""><a id=""AEN12"" name=""AEN12""></a>
<p>This article gives some brief instructions on installing FreeBSD/sparc64 5.4-RELEASE,
with particular emphasis given to obtaining a FreeBSD distribution. Some notes on
troubleshooting and frequently-asked questions are also given.</p>
</div>
</blockquote>

<div class=""SECT1"">
<hr />
<h2 class=""SECT1""><a id=""INSTALL"" name=""INSTALL"">1 Installing FreeBSD</a></h2>

<p>This section documents the process of installing a new distribution of FreeBSD. These
instructions pay particular emphasis to the process of obtaining the FreeBSD 5.4-RELEASE
distribution and to beginning the installation procedure. The <a
href=""http://www.FreeBSD.org/doc/en_US.ISO8859-1/books/handbook/install.html""
target=""_top"">``Installing FreeBSD''</a> chapter of the <a
href=""http://www.FreeBSD.org/doc/en_US.ISO8859-1/books/handbook/"" target=""_top"">FreeBSD
Handbook</a> provides more in-depth information about the installation program itself,
including a guided walkthrough with screenshots.</p>

<p>If you are upgrading from a previous release of FreeBSD, please see <a
href=""#UPGRADING"">Section 3</a> for instructions on upgrading.</p>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""GETTING-STARTED"" name=""GETTING-STARTED"">1.1 Getting
Started</a></h3>

<p>Probably the most important pre-installation step that can be taken is that of reading
the various instruction documents provided with FreeBSD. A roadmap of documents
pertaining to this release of FreeBSD can be found in <tt
class=""FILENAME"">README.TXT</tt>, which can usually be found in the same location as this
file; most of these documents, such as the release notes and the hardware compatibility
list, are also accessible in the Documentation menu of the installer.</p>

<p>Note that on-line versions of the FreeBSD <a
href=""http://www.FreeBSD.org/doc/en_US.ISO8859-1/books/faq/"" target=""_top"">FAQ</a> and <a
href=""http://www.FreeBSD.org/doc/en_US.ISO8859-1/books/handbook/""
target=""_top"">Handbook</a> are also available from the <a href=""http://www.FreeBSD.org/""
target=""_top"">FreeBSD Project Web site</a>, if you have an Internet connection.</p>

<p>This collection of documents may seem daunting, but the time spent reading them will
likely be saved many times over. Being familiar with what resources are available can
also be helpful in the event of problems during installation.</p>

<p>The best laid plans sometimes go awry, so if you run into trouble take a look at <a
href=""#TROUBLE"">Section 4</a>, which contains valuable troubleshooting information. You
should also read an updated copy of <tt class=""FILENAME"">ERRATA.TXT</tt> before
installing, since this will alert you to any problems which have reported in the interim
for your particular release.</p>

<div class=""IMPORTANT"">
<blockquote class=""IMPORTANT"">
<p><b>Important:</b> While FreeBSD does its best to safeguard against accidental loss of
data, it's still more than possible to <span class=""emphasis""><i class=""EMPHASIS"">wipe
out your entire disk</i></span> with this installation if you make a mistake. Please do
not proceed to the final FreeBSD installation menu unless you've adequately backed up any
important data first.</p>
</blockquote>
</div>
</div>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""AEN37"" name=""AEN37"">1.2 Hardware Requirements</a></h3>

<p>FreeBSD for the UltraSPARC supports the platforms described in <tt
class=""FILENAME"">HARDWARE.TXT</tt>.</p>

<p>You will need a dedicated disk for FreeBSD/sparc64. It is not possible to share a disk
with another operating system at this time.</p>

<p>If you are not familiar with configuring hardware for FreeBSD, you should be sure to
read the <tt class=""FILENAME"">HARDWARE.TXT</tt> file; it contains important information
on what hardware is supported by FreeBSD.</p>
</div>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""FLOPPIES"" name=""FLOPPIES"">1.3 Floppy Disk Image
Instructions</a></h3>
</div>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""START-INSTALLATION"" name=""START-INSTALLATION"">1.4 Installing
FreeBSD from CDROM or the Internet</a></h3>

<p>Most sparc64 systems are set up to boot automatically from disk. To install FreeBSD,
you need to boot over the network or from a CDROM, which requires you to break into the
PROM (OpenFirmware).</p>

<p>To do this, reboot the system, and wait until the boot message appears. It depends on
the model, but should look about like:</p>

<pre class=""SCREEN"">
Sun Blade 100 (UltraSPARC-IIe), Keyboard Present
Copyright 1998-2001 Sun Microsystems, Inc.  All rights reserved.
OpenBoot 4.2, 128 MB memory installed, Serial #51090132.
Ethernet address 0:3:ba:b:92:d4, Host ID: 830b92d4.
</pre>

<p>If your system proceeds to boot from disk at this point, you need to press <b
class=""KEYCAP"">L1</b>+<b class=""KEYCAP"">A</b> or <b class=""KEYCAP"">Stop</b>+<b
class=""KEYCAP"">A</b> on the keyboard, or send a <tt class=""COMMAND"">BREAK</tt> over the
serial console (using for example <tt class=""COMMAND"">~#</tt> in <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=tip&sektion=1&manpath=FreeBSD+5.4-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">tip</span>(1)</span></a> or <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=cu&sektion=1&manpath=FreeBSD+5.4-RELEASE""><span
 class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">cu</span>(1)</span></a>) to get to the
PROM prompt. It looks like this:</p>

<pre class=""SCREEN"">
<samp class=""PROMPT"">ok    </samp>     <a id=""PROMPT-SINGLE""
name=""PROMPT-SINGLE""><b>(1)</b></a>
<samp class=""PROMPT"">ok {0}</samp>     <a id=""PROMPT-SMP""
name=""PROMPT-SMP""><b>(2)</b></a>
</pre>

<div class=""CALLOUTLIST"">
<dl compact=""COMPACT"">
<dt><a href=""#PROMPT-SINGLE""><b>(1)</b></a></dt>

<dd>This is the prompt used on systems with just one CPU.</dd>

<dt><a href=""#PROMPT-SMP""><b>(2)</b></a></dt>

<dd>This is the prompt used on SMP systems, the digit indicates the number of the active
CPU.</dd>
</dl>
</div>

<p>At this point, place the CDROM into your drive, and from the PROM prompt, type <tt
class=""COMMAND"">boot cdrom</tt>.</p>
</div>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""AEN212"" name=""AEN212"">1.5 Detail on various installation
types</a></h3>

<p>Once you've gotten yourself to the initial installation screen somehow, you should be
able to follow the various menu prompts and go from there. If you've never used the
FreeBSD installation before, you are also encouraged to read some of the documentation in
the Documentation submenu as well as the general ``Usage'' instructions on the first
menu.</p>

<div class=""NOTE"">
<blockquote class=""NOTE"">
<p><b>Note:</b> If you get stuck at a screen, press the <b class=""KEYCAP"">F1</b> key for
online documentation relevant to that specific section.</p>
</blockquote>
</div>

<p>If you've never installed FreeBSD before, or even if you have, the ``Standard''
installation mode is the most recommended since it makes sure that you'll visit all the
various important checklist items along the way. If you're much more comfortable with the
FreeBSD installation process and know <span class=""emphasis""><i
class=""EMPHASIS"">exactly</i></span> what you want to do, use the ``Express'' or
``Custom'' installation options. If you're upgrading an existing system, use the
``Upgrade'' option.</p>

<p>The FreeBSD installer supports the direct use of floppy, DOS, tape, CDROM, FTP, NFS
and UFS partitions as installation media; further tips on installing from each type of
media are listed below.</p>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""AEN251"" name=""AEN251"">1.5.1 Installing from a Network
CDROM</a></h4>

<p>If you simply wish to install from a local CDROM drive then see <a
href=""#START-INSTALLATION"">Section 1.4</a>. If you don't have a CDROM drive on your
system and wish to use a FreeBSD distribution CD in the CDROM drive of another system to
which you have network connectivity, there are also several ways of going about it:</p>

<ul>
<li>
<p>If you would be able to FTP install FreeBSD directly from the CDROM drive in some
FreeBSD machine, it's quite easy: You ensure an FTP server is running and then simply add
the following line to the password file (using the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=vipw&sektion=8&manpath=FreeBSD+5.4-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">vipw</span>(8)</span></a>
command):</p>

<pre class=""SCREEN"">
ftp:*:99:99::0:0:FTP:/cdrom:/sbin/nologin
</pre>

<p>On the machine on which you are running the install, go to the Options menu and set
Release Name to <tt class=""LITERAL"">any</tt>. You may then choose a Media type of <tt
class=""LITERAL"">FTP</tt> and type in <tt class=""FILENAME"">ftp://<tt
class=""REPLACEABLE""><i>machine</i></tt></tt> after picking ``URL'' in the ftp sites
menu.</p>

<div class=""WARNING"">
<blockquote class=""WARNING"">
<p><b>Warning:</b> This may allow anyone on the local network (or Internet) to make
``anonymous FTP'' connections to this machine, which may not be desirable.</p>
</blockquote>
</div>
</li>

<li>
<p>If you would rather use NFS to export the CDROM directly to the machine(s) you'll be
installing from, you need to first add an entry to the <tt
class=""FILENAME"">/etc/exports</tt> file (on the machine with the CDROM drive). The
example below allows the machine <tt class=""HOSTID"">ziggy.foo.com</tt> to mount the CDROM
directly via NFS during installation:</p>

<pre class=""SCREEN"">
/cdrom          -ro             ziggy.foo.com
</pre>

<p>The machine with the CDROM must also be configured as an NFS server, of course, and if
you're not sure how to do that then an NFS installation is probably not the best choice
for you unless you're willing to read up on <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=rc.conf&sektion=5&manpath=FreeBSD+5.4-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">rc.conf</span>(5)</span></a> and
configure things appropriately. Assuming that this part goes smoothly, you should be able
to enter: <tt class=""FILENAME""><tt class=""REPLACEABLE""><i>cdrom-host</i></tt>:/cdrom</tt>
as the path for an NFS installation when the target machine is installed, e.g. <tt
class=""FILENAME"">wiggy:/cdrom</tt>.</p>
</li>
</ul>
</div>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""AEN283"" name=""AEN283"">1.5.2 Installing from Floppies</a></h4>

<p>If you must install from floppy disks, either due to unsupported hardware or just
because you enjoy doing things the hard way, you must first prepare some floppies for the
install.</p>

<p>First, make your boot floppies as described in <a href=""#FLOPPIES"">Section
1.3</a>.</p>

<p>Second, peruse <a href=""#LAYOUT"">Section 2</a> and pay special attention to the
``Distribution Format'' section since it describes which files you're going to need to
put onto floppy and which you can safely skip.</p>

<p>Next you will need, at minimum, as many 1.44MB floppies as it takes to hold all files
in the <tt class=""FILENAME"">bin</tt> (binary distribution) directory. If you're preparing
these floppies under DOS, then these floppies <span class=""emphasis""><i
class=""EMPHASIS"">must</i></span> be formatted using the MS-DOS <tt
class=""FILENAME"">FORMAT</tt> command. If you're using Windows, use the Windows File
Manager format command.</p>

<div class=""IMPORTANT"">
<blockquote class=""IMPORTANT"">
<p><b>Important:</b> Frequently, floppy disks come ``factory preformatted''. While
convenient, many problems reported by users in the past have resulted from the use of
improperly formatted media. Re-format them yourself, just to make sure.</p>
</blockquote>
</div>

<p>If you're creating the floppies from another FreeBSD machine, a format is still not a
bad idea though you don't need to put a DOS filesystem on each floppy. You can use the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=disklabel&sektion=8&manpath=FreeBSD+5.4-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">disklabel</span>(8)</span></a> and
<a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=newfs&sektion=8&manpath=FreeBSD+5.4-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">newfs</span>(8)</span></a>
commands to put a UFS filesystem on a floppy, as the following sequence of commands
illustrates:</p>

<pre class=""SCREEN"">
<samp class=""PROMPT"">#</samp> <kbd class=""USERINPUT"">fdformat -f 1440 fd0</kbd>
<samp class=""PROMPT"">#</samp> <kbd class=""USERINPUT"">disklabel -w fd0 floppy3</kbd>
<samp class=""PROMPT"">#</samp> <kbd class=""USERINPUT"">newfs -i 65536 /dev/fd0</kbd>
</pre>

<p>After you've formatted the floppies for DOS or UFS, you'll need to copy the files onto
them. The distribution files are sized so that a floppy disk will hold a single file.
Each distribution should go into its own subdirectory on the floppy, e.g.: <tt
class=""FILENAME"">a:\\bin\\bin.inf</tt>, <tt class=""FILENAME"">a:\\bin\\bin.aa</tt>, <tt
class=""FILENAME"">a:\\bin\\bin.ab</tt>, ...</p>

<div class=""IMPORTANT"">
<blockquote class=""IMPORTANT"">
<p><b>Important:</b> The <tt class=""FILENAME"">bin.inf</tt> file also needs to go on the
first floppy of the <tt class=""FILENAME"">bin</tt> set since it is read by the
installation program in order to figure out how many additional pieces to look for when
fetching and concatenating the distribution. When putting distributions onto floppies,
the <tt class=""FILENAME"">distname.inf</tt> file <span class=""emphasis""><i
class=""EMPHASIS"">must</i></span> occupy the first floppy of each distribution set.</p>
</blockquote>
</div>

<p>Once you come to the Media screen of the install, select ``Floppy'' and you'll be
prompted for the rest.</p>
</div>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""AEN352"" name=""AEN352"">1.5.4 Installing from QIC/SCSI
Tape</a></h4>

<p>When installing from tape, the installation program expects the files to be simply
tar'ed onto it, so after fetching all of the files for the distributions you're
interested in, simply use <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=tar&sektion=1&manpath=FreeBSD+5.4-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">tar</span>(1)</span></a> to get
them onto the tape with a command something like this:</p>

<pre class=""SCREEN"">
<samp class=""PROMPT"">#</samp> <kbd class=""USERINPUT"">cd <tt
class=""REPLACEABLE""><i>/where/you/have/your/dists</i></tt></kbd>
<samp class=""PROMPT"">#</samp> <kbd class=""USERINPUT"">tar cvf /dev/sa0 <tt
class=""REPLACEABLE""><i>dist1</i></tt> .. <tt class=""REPLACEABLE""><i>dist2</i></tt></kbd>
</pre>

<p>When you go to do the installation, you should also make sure that you leave enough
room in some temporary directory (which you'll be allowed to choose) to accommodate the
<span class=""emphasis""><i class=""EMPHASIS"">full</i></span> contents of the tape you've
created. Due to the non-random access nature of tapes, this method of installation
requires quite a bit of temporary storage. You should expect to require as much temporary
storage as you have stuff written on tape.</p>

<div class=""NOTE"">
<blockquote class=""NOTE"">
<p><b>Note:</b> When going to do the installation, the tape must be in the drive <span
class=""emphasis""><i class=""EMPHASIS"">before</i></span> booting from the boot floppies.
The installation ``probe'' may otherwise fail to find it.</p>
</blockquote>
</div>

<p>Now create a boot floppy as described in <a href=""#FLOPPIES"">Section 1.3</a> and
proceed with the installation.</p>
</div>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""FTPNFS"" name=""FTPNFS"">1.5.5 Installing over a Network using FTP
or NFS</a></h4>

<p>After making the boot floppies as described in the first section, you can load the
rest of the installation over a network using one of 3 types of connections: serial port,
parallel port, or Ethernet.</p>

<div class=""SECT4"">
<hr />
<h5 class=""SECT4""><a id=""AEN377"" name=""AEN377"">1.5.5.1 Serial Port</a></h5>

<p>SLIP support is rather primitive, and is limited primarily to hard-wired links, such
as a serial cable running between two computers. The link must be hard-wired because the
SLIP installation doesn't currently offer a dialing capability. If you need to dial out
with a modem or otherwise dialog with the link before connecting to it, then the PPP
utility should be used instead.</p>

<p>If you're using PPP, make sure that you have your Internet Service Provider's IP
address and DNS information handy as you'll need to know it fairly early in the
installation process. You may also need to know your own IP address, though PPP supports
dynamic address negotiation and may be able to pick up this information directly from
your ISP if they support it.</p>

<p>You will also need to know how to use the various ``AT commands'' for dialing out with
your particular brand of modem as the PPP dialer provides only a very simple terminal
emulator.</p>
</div>

<div class=""SECT4"">
<hr />
<h5 class=""SECT4""><a id=""AEN383"" name=""AEN383"">1.5.5.2 Parallel Port</a></h5>

<p>If a hard-wired connection to another FreeBSD or Linux machine is available, you might
also consider installing over a ``laplink'' style parallel port cable. The data rate over
the parallel port is much higher than what is typically possible over a serial line (up
to 50k/sec), thus resulting in a quicker installation. It's not typically necessary to
use ``real'' IP addresses when using a point-to-point parallel cable in this way and you
can generally just use RFC 1918 style addresses for the ends of the link (e.g. <tt
class=""HOSTID"">10.0.0.1</tt>, <tt class=""HOSTID"">10.0.0.2</tt>, etc).</p>

<div class=""IMPORTANT"">
<blockquote class=""IMPORTANT"">
<p><b>Important:</b> If you use a Linux machine rather than a FreeBSD machine as your
PLIP peer, you will also have to specify <code class=""OPTION"">link0</code> in the TCP/IP
setup screen's ``extra options for ifconfig'' field in order to be compatible with
Linux's slightly different PLIP protocol.</p>
</blockquote>
</div>
</div>

<div class=""SECT4"">
<hr />
<h5 class=""SECT4""><a id=""AEN394"" name=""AEN394"">1.5.5.3 Ethernet</a></h5>

<p>FreeBSD supports most common Ethernet cards; a table of supported cards is provided as
part of the FreeBSD Hardware Notes (see <tt class=""FILENAME"">HARDWARE.TXT</tt> in the
Documentation menu on the boot floppy or the top level directory of the CDROM). If you
are using one of the supported PCMCIA Ethernet cards, also be sure that it's plugged in
<span class=""emphasis""><i class=""EMPHASIS"">before</i></span> the laptop is powered on.
FreeBSD does not, unfortunately, currently support ``hot insertion'' of PCMCIA cards
during installation.</p>

<p>You will also need to know your IP address on the network, the <code
class=""OPTION"">netmask</code> value for your subnet and the name of your machine. Your
system administrator can tell you which values are appropriate to your particular network
setup. If you will be referring to other hosts by name rather than IP address, you'll
also need a name server and possibly the address of a gateway (if you're using PPP, it's
your provider's IP address) to use in talking to it. If you want to install by FTP via an
HTTP proxy (see below), you will also need the proxy's address.</p>

<p>If you do not know the answers to these questions then you should really probably talk
to your system administrator <span class=""emphasis""><i class=""EMPHASIS"">first</i></span>
before trying this type of installation. Using a randomly chosen IP address or netmask on
a live network is almost guaranteed not to work, and will probably result in a lecture
from said system administrator.</p>

<p>Once you have a network connection of some sort working, the installation can continue
over NFS or FTP.</p>
</div>

<div class=""SECT4"">
<hr />
<h5 class=""SECT4""><a id=""AEN405"" name=""AEN405"">1.5.5.4 NFS installation tips</a></h5>

<p>NFS installation is fairly straight-forward: Simply copy the FreeBSD distribution
files you want onto a server somewhere and then point the NFS media selection at it.</p>

<p>If this server supports only ``privileged port'' access (this is generally the default
for Sun and Linux workstations), you may need to set this option in the Options menu
before installation can proceed.</p>

<p>If you have a poor quality Ethernet card which suffers from very slow transfer rates,
you may also wish to toggle the appropriate Options flag.</p>

<p>In order for NFS installation to work, the server must also support ``subdir mounts'',
e.g. if your FreeBSD distribution directory lives on <tt
class=""FILENAME"">wiggy:/usr/archive/stuff/FreeBSD</tt>, then <tt
class=""HOSTID"">wiggy</tt> will have to allow the direct mounting of <tt
class=""FILENAME"">/usr/archive/stuff/FreeBSD</tt>, not just <tt class=""FILENAME"">/usr</tt>
or <tt class=""FILENAME"">/usr/archive/stuff</tt>.</p>

<p>In FreeBSD's <tt class=""FILENAME"">/etc/exports</tt> file this is controlled by the
<code class=""OPTION"">-alldirs</code> option. Other NFS servers may have different
conventions. If you are getting <tt class=""LITERAL"">Permission Denied</tt> messages from
the server then it's likely that you don't have this properly enabled.</p>
</div>

<div class=""SECT4"">
<hr />
<h5 class=""SECT4""><a id=""AEN422"" name=""AEN422"">1.5.5.5 FTP Installation tips</a></h5>

<p>FTP installation may be done from any mirror site containing a reasonably up-to-date
version of FreeBSD. A full menu of reasonable choices for almost any location in the
world is provided in the FTP site menu during installation.</p>

<p>If you are installing from some other FTP site not listed in this menu, or you are
having troubles getting your name server configured properly, you can also specify your
own URL by selecting the ``URL'' choice in that menu. A URL can contain a hostname or an
IP address, so something like the following would work in the absence of a name
server:</p>

<pre class=""SCREEN"">
ftp://216.66.64.162/pub/FreeBSD/releases/sparc64/4.2-RELEASE
</pre>

<p>There are three FTP installation modes you can use:</p>

<ul>
<li>
<p>FTP: This method uses the standard ``Active'' mode for transfers, in which the server
initiates a connection to the client. This will not work through most firewalls but will
often work best with older FTP servers that do not support passive mode. If your
connection hangs with passive mode, try this one.</p>
</li>

<li>
<p>FTP Passive: This sets the FTP ""Passive"" mode which prevents the server from opening
connections to the client. This option is best for users to pass through firewalls that
do not allow incoming connections on random port addresses.</p>
</li>

<li>
<p>FTP via an HTTP proxy: This option instructs FreeBSD to use HTTP to connect to a proxy
for all FTP operations. The proxy will translate the requests and send them to the FTP
server. This allows the user to pass through firewalls that do not allow FTP at all, but
offer an HTTP proxy. You must specify the hostname of the proxy in addition to the FTP
server.</p>

<p>In the rare case that you have an FTP proxy that does not go through HTTP, you can
specify the URL as something like:</p>

<pre class=""SCREEN"">
<kbd class=""USERINPUT"">ftp://foo.bar.com:<tt
class=""REPLACEABLE""><i>port</i></tt>/pub/FreeBSD</kbd>
</pre>

<p>In the URL above, <tt class=""REPLACEABLE""><i>port</i></tt> is the port number of the
proxy FTP server.</p>
</li>
</ul>

<br />
<br />
</div>
</div>
</div>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""AEN473"" name=""AEN473"">1.6 Question and Answer Section for
UltraSPARC Architecture Users</a></h3>
</div>
</div>

<div class=""SECT1"">
<hr />
<h2 class=""SECT1""><a id=""LAYOUT"" name=""LAYOUT"">2 Distribution Format</a></h2>

<p>A typical FreeBSD distribution directory looks something like this (exact details may
vary depending on version, architecture, and other factors):</p>

<pre class=""SCREEN"">
ERRATA.HTM      README.TXT      compat1x        dict            kernel
ERRATA.TXT      RELNOTES.HTM    compat20        doc             manpages
HARDWARE.HTM    RELNOTES.TXT    compat21        docbook.css     packages
HARDWARE.TXT    base            compat22        filename.txt    ports
INSTALL.HTM     boot            compat3x        floppies        proflibs
INSTALL.TXT     catpages        compat4x        games           src
README.HTM      cdrom.inf       crypto          info            tools
</pre>

<p>These same files are contained in the first CDROM of a multi-disk set, but they are
laid out slightly differently on the disk. On most architectures, the installation CDROM
also contains a ``live filesystem'' in addition to the distribution files. The live
filesystem is useful when repairing or troubleshooting an existing FreeBSD installation
(see <a href=""#TROUBLE"">Section 4</a> for how to use this).</p>

<p>The <tt class=""FILENAME"">floppies</tt> directory will be of particular interest to
users who are unable to boot from the CDROM media (but are able to read the CDROM by
other means). It is easy to generate a set of 1.44MB boot floppies from the <tt
class=""FILENAME"">floppies</tt> directory (see <a href=""#FLOPPIES"">Section 1.3</a> for
instructions on how to do this) and use these to start an installation from CDROM, FTP,
or NFS. The rest of the data needed during the installation will be obtained
automatically based on your selections. If you've never installed FreeBSD before, you
also want to read the entirety of this document (the installation instructions) file.</p>

<p>If you're trying to do some other type of installation or are merely curious about how
a distribution is organized, what follows is a more thorough description of some of these
items in more detail:</p>

<ol type=""1"">
<li>
<p>The <tt class=""FILENAME"">*.TXT</tt> and <tt class=""FILENAME"">*.HTM</tt> files contain
documentation (for example, this document is contained in both <tt
class=""FILENAME"">INSTALL.TXT</tt> and <tt class=""FILENAME"">INSTALL.HTM</tt>) and should
be read before starting an installation. The <tt class=""FILENAME"">*.TXT</tt> files are
plain text, while the <tt class=""FILENAME"">*.HTM</tt> files are HTML files that can be
read by almost any Web browser. Some distributions may contain documentation in other
formats as well, such as PDF or PostScript.</p>
</li>

<li>
<p><tt class=""FILENAME"">docbook.css</tt> is a Cascading Style Sheet (CSS) file used by
some Web browsers for formatting the HTML documentation.</p>
</li>

<li>
<p>The <tt class=""FILENAME"">base</tt>, <tt class=""FILENAME"">catpages</tt>, <tt
class=""FILENAME"">crypto</tt>, <tt class=""FILENAME"">dict</tt>, <tt
class=""FILENAME"">doc</tt>, <tt class=""FILENAME"">games</tt>, <tt
class=""FILENAME"">info</tt>, <tt class=""FILENAME"">manpages</tt>, <tt
class=""FILENAME"">proflibs</tt>, and <tt class=""FILENAME"">src</tt> directories contain the
primary distribution components of FreeBSD itself and are split into smaller files for
easy packing onto floppies (should that be necessary).</p>
</li>

<li>
<p>The <tt class=""FILENAME"">compat1x</tt>, <tt class=""FILENAME"">compat20</tt>, <tt
class=""FILENAME"">compat21</tt>, <tt class=""FILENAME"">compat22</tt>, <tt
class=""FILENAME"">compat3x</tt>, and <tt class=""FILENAME"">compat4x</tt> directories
contain distributions for compatibility with older releases and are distributed as single
gzip'd tar files - they can be installed during release time or later by running their
<tt class=""FILENAME"">install.sh</tt> scripts.</p>
</li>

<li>
<p>The <tt class=""FILENAME"">floppies/</tt> subdirectory contains the floppy installation
images; further information on using them can be found in <a href=""#FLOPPIES"">Section
1.3</a>.</p>
</li>

<li>
<p>The <tt class=""FILENAME"">packages</tt> and <tt class=""FILENAME"">ports</tt> directories
contain the FreeBSD Packages and Ports Collections. Packages may be installed from the
packages directory by running the command:</p>

<pre class=""SCREEN"">
<samp class=""PROMPT"">#</samp><kbd
class=""USERINPUT"">/stand/sysinstall configPackages</kbd>
</pre>

<p>Packages can also be installed by feeding individual filenames in <tt
class=""FILENAME"">packages</tt>/ to the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=pkg_add&sektion=1&manpath=FreeBSD+5.4-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">pkg_add</span>(1)</span></a>
command.</p>

<p>The Ports Collection may be installed like any other distribution and requires about
190MB unpacked. More information on the ports collection may be obtained from <a
href=""http://www.FreeBSD.org/ports/"" target=""_top"">http://www.FreeBSD.org/ports/</a> or
locally from <tt class=""FILENAME"">/usr/share/doc/handbook</tt> if you've installed the
<tt class=""FILENAME"">doc</tt> distribution.</p>
</li>

<li>
<p>Last of all, the <tt class=""FILENAME"">tools</tt> directory contains various DOS tools
for discovering disk geometries, installing boot managers and the like. It is purely
optional and provided only for user convenience.</p>
</li>
</ol>

<br />
<br />
<p>A typical distribution directory (for example, the <tt class=""FILENAME"">info</tt>
distribution) looks like this internally:</p>

<pre class=""SCREEN"">
CHECKSUM.MD5    info.ab         info.ad         info.inf        install.sh
info.aa         info.ac         info.ae         info.mtree
</pre>

<p>The <tt class=""FILENAME"">CHECKSUM.MD5</tt> file contains MD5 signatures for each file,
should data corruption be suspected, and is purely for reference. It is not used by the
actual installation and does not need to be copied with the rest of the distribution
files. The <tt class=""FILENAME"">info.a*</tt> files are split, gzip'd tar files, the
contents of which can be viewed by doing:</p>

<pre class=""SCREEN"">
<samp class=""PROMPT"">#</samp> <kbd class=""USERINPUT"">cat info.a* | tar tvzf -</kbd>
</pre>

<p>During installation, they are automatically concatenated and extracted by the
installation procedure.</p>

<p>The <tt class=""FILENAME"">info.inf</tt> file is also necessary since it is read by the
installation program in order to figure out how many pieces to look for when fetching and
concatenating the distribution. When putting distributions onto floppies, the <tt
class=""FILENAME"">.inf</tt> file <span class=""emphasis""><i
class=""EMPHASIS"">must</i></span> occupy the first floppy of each distribution set!</p>

<p>The <tt class=""FILENAME"">info.mtree</tt> file is another non-essential file which is
provided for user reference. It contains the MD5 signatures of the <span
class=""emphasis""><i class=""EMPHASIS"">unpacked</i></span> distribution files and can be
later used with the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=mtree&sektion=8&manpath=FreeBSD+5.4-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">mtree</span>(8)</span></a> program
to verify the installation permissions and checksums against any possible modifications
to the file. When used with the <tt class=""FILENAME"">base</tt> distribution, this can be
an excellent way of detecting trojan horse attacks on your system.</p>

<p>Finally, the <tt class=""FILENAME"">install.sh</tt> file is for use by those who want to
install the distribution after installation time. To install the info distribution from
CDROM after a system was installed, for example, you'd do:</p>

<pre class=""SCREEN"">
<samp class=""PROMPT"">#</samp> <kbd class=""USERINPUT"">cd /cdrom/info</kbd>
<samp class=""PROMPT"">#</samp> <kbd class=""USERINPUT"">sh install.sh</kbd>
</pre>
</div>

<div class=""SECT1"">
<hr />
<h2 class=""SECT1""><a id=""UPGRADING"" name=""UPGRADING"">3 Upgrading FreeBSD</a></h2>

<p>These instructions describe a procedure for doing a binary upgrade from an older
version of FreeBSD.</p>

<div class=""WARNING"">
<blockquote class=""WARNING"">
<p><b>Warning:</b> While the FreeBSD upgrade procedure does its best to safeguard against
accidental loss of data, it is still more than possible to <span class=""emphasis""><i
class=""EMPHASIS"">wipe out your entire disk</i></span> with this installation! Please do
not accept the final confirmation request unless you have adequately backed up any
important data files.</p>
</blockquote>
</div>

<div class=""IMPORTANT"">
<blockquote class=""IMPORTANT"">
<p><b>Important:</b> These notes assume that you are using the version of <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=sysinstall&sektion=8&manpath=FreeBSD+5.4-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">sysinstall</span>(8)</span></a>
supplied with the version of FreeBSD to which you intend to upgrade. Using a mismatched
version of <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=sysinstall&sektion=8&manpath=FreeBSD+5.4-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">sysinstall</span>(8)</span></a> is
almost guaranteed to cause problems and has been known to leave systems in an unusable
state. The most commonly made mistake in this regard is the use of an old copy of <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=sysinstall&sektion=8&manpath=FreeBSD+5.4-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">sysinstall</span>(8)</span></a>
from an existing installation to upgrade to a newer version of FreeBSD. This is <span
class=""emphasis""><i class=""EMPHASIS"">not</i></span> recommended.</p>
</blockquote>
</div>

<div class=""WARNING"">
<blockquote class=""WARNING"">
<p><b>Warning:</b> Binary upgrades to FreeBSD 5.4-RELEASE from FreeBSD 4-STABLE are not
supported at this time. There are some files present in a FreeBSD 4-STABLE whose presence
can be disruptive, but are not removed by a binary upgrade. One notable example is that
an old <tt class=""FILENAME"">/usr/include/g++</tt> directory will cause C++ programs to
compile incorrectly (or not at all).</p>

<p>These upgrade instructions are provided for the use of users upgrading from relatively
recent FreeBSD 5-STABLE snapshots.</p>
</blockquote>
</div>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""AEN701"" name=""AEN701"">3.1 Introduction</a></h3>

<p>The upgrade procedure replaces distributions selected by the user with those
corresponding to the new FreeBSD release. It preserves standard system configuration
data, as well as user data, installed packages and other software.</p>

<p>Administrators contemplating an upgrade are encouraged to study this section in its
entirety before commencing an upgrade. Failure to do so may result in a failed upgrade or
loss of data.</p>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""AEN705"" name=""AEN705"">3.1.1 Upgrade Overview</a></h4>

<p>Upgrading of a distribution is performed by extracting the new version of the
component over the top of the previous version. Files belonging to the old distribution
are not deleted.</p>

<p>System configuration is preserved by retaining and restoring the previous version of
the following files:</p>

<p><tt class=""FILENAME"">Xaccel.ini</tt>, <tt class=""FILENAME"">XF86Config</tt>, <tt
class=""FILENAME"">adduser.conf</tt>, <tt class=""FILENAME"">aliases</tt>, <tt
class=""FILENAME"">aliases.db</tt>, <tt class=""FILENAME"">amd.map</tt>, <tt
class=""FILENAME"">crontab</tt>, <tt class=""FILENAME"">csh.cshrc</tt>, <tt
class=""FILENAME"">csh.login</tt>, <tt class=""FILENAME"">csh.logout</tt>, <tt
class=""FILENAME"">cvsupfile</tt>, <tt class=""FILENAME"">dhclient.conf</tt>, <tt
class=""FILENAME"">disktab</tt>, <tt class=""FILENAME"">dm.conf</tt>, <tt
class=""FILENAME"">dumpdates</tt>, <tt class=""FILENAME"">exports</tt>, <tt
class=""FILENAME"">fbtab</tt>, <tt class=""FILENAME"">fstab</tt>, <tt
class=""FILENAME"">ftpusers</tt>, <tt class=""FILENAME"">gettytab</tt>, <tt
class=""FILENAME"">gnats</tt>, <tt class=""FILENAME"">group</tt>, <tt
class=""FILENAME"">hosts</tt>, <tt class=""FILENAME"">hosts.allow</tt>, <tt
class=""FILENAME"">hosts.equiv</tt>, <tt class=""FILENAME"">hosts.lpd</tt>, <tt
class=""FILENAME"">inetd.conf</tt>, <tt class=""FILENAME"">localtime</tt>, <tt
class=""FILENAME"">login.access</tt>, <tt class=""FILENAME"">login.conf</tt>, <tt
class=""FILENAME"">mail</tt>, <tt class=""FILENAME"">mail.rc</tt>, <tt
class=""FILENAME"">make.conf</tt>, <tt class=""FILENAME"">manpath.config</tt>, <tt
class=""FILENAME"">master.passwd</tt>, <tt class=""FILENAME"">motd</tt>, <tt
class=""FILENAME"">namedb</tt>, <tt class=""FILENAME"">networks</tt>, <tt
class=""FILENAME"">newsyslog.conf</tt>, <tt class=""FILENAME"">nsmb.conf</tt>, <tt
class=""FILENAME"">nsswitch.conf</tt>, <tt class=""FILENAME"">pam.conf</tt>, <tt
class=""FILENAME"">passwd</tt>, <tt class=""FILENAME"">periodic</tt>, <tt
class=""FILENAME"">ppp</tt>, <tt class=""FILENAME"">printcap</tt>, <tt
class=""FILENAME"">profile</tt>, <tt class=""FILENAME"">pwd.db</tt>, <tt
class=""FILENAME"">rc.conf</tt>, <tt class=""FILENAME"">rc.conf.local</tt>, <tt
class=""FILENAME"">rc.firewall</tt>, <tt class=""FILENAME"">rc.local</tt>, <tt
class=""FILENAME"">remote</tt>, <tt class=""FILENAME"">resolv.conf</tt>, <tt
class=""FILENAME"">rmt</tt>, <tt class=""FILENAME"">sendmail.cf</tt>, <tt
class=""FILENAME"">sendmail.cw</tt>, <tt class=""FILENAME"">services</tt>, <tt
class=""FILENAME"">shells</tt>, <tt class=""FILENAME"">skeykeys</tt>, <tt
class=""FILENAME"">spwd.db</tt>, <tt class=""FILENAME"">ssh</tt>, <tt
class=""FILENAME"">syslog.conf</tt>, <tt class=""FILENAME"">ttys</tt>, <tt
class=""FILENAME"">uucp</tt></p>

<p>The versions of these files which correspond to the new version are moved to <tt
class=""FILENAME"">/etc/upgrade/</tt>. The system administrator may peruse these new
versions and merge components as desired. Note that many of these files are
interdependent, and the best merge procedure is to copy all site-specific data from the
current files into the new.</p>

<p>During the upgrade procedure, the administrator is prompted for a location into which
all files from <tt class=""FILENAME"">/etc/</tt> are saved. In the event that local
modifications have been made to other files, they may be subsequently retrieved from this
location.</p>
</div>
</div>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""AEN779"" name=""AEN779"">3.2 Procedure</a></h3>

<p>This section details the upgrade procedure. Particular attention is given to items
which substantially differ from a normal installation.</p>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""AEN782"" name=""AEN782"">3.2.1 Backup</a></h4>

<p>User data and system configuration should be backed up before upgrading. While the
upgrade procedure does its best to prevent accidental mistakes, it is possible to
partially or completely destroy data and configuration information.</p>
</div>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""AEN785"" name=""AEN785"">3.2.2 Mount Filesystems</a></h4>

<p>The disklabel editor is entered with the nominated disk's filesystem devices listed.
Prior to commencing the upgrade, the administrator should make a note of the device names
and corresponding mountpoints. These mountpoints should be entered here. <span
class=""emphasis""><i class=""EMPHASIS"">Do not</i></span> set the ``newfs flag'' for any
filesystems, as this will cause data loss.</p>
</div>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""AEN790"" name=""AEN790"">3.2.3 Select Distributions</a></h4>

<p>When selecting distributions, there are no constraints on which must be selected. As a
general rule, the <tt class=""LITERAL"">base</tt> distribution should be selected for an
update, and the <tt class=""LITERAL"">man</tt> distribution if manpages are already
installed. Other distributions may be selected beyond those originally installed if the
administrator wishes to add additional functionality.</p>
</div>

<div class=""SECT3"">
<hr />
<h4 class=""SECT3""><a id=""FSTAB"" name=""FSTAB"">3.2.4 After Installation</a></h4>

<p>Once the installation procedure has completed, the administrator is prompted to
examine the new configuration files. At this point, checks should be made to ensure that
the system configuration is valid. In particular, the <tt
class=""FILENAME"">/etc/rc.conf</tt> and <tt class=""FILENAME"">/etc/fstab</tt> files should
be checked.</p>
</div>
</div>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""AEN800"" name=""AEN800"">3.3 Upgrading from Source Code</a></h3>

<p>Those interested in an upgrade method that allows more flexibility and sophistication
should take a look at <a
href=""http://www.FreeBSD.org/doc/en_US.ISO8859-1/books/handbook/cutting-edge.html""
target=""_top"">The Cutting Edge</a> in the FreeBSD Handbook. This procedure involves
rebuilding all of FreeBSD from source code. It requires reliable network connectivity,
extra disk space, and time, but has advantages for networks and other more complex
installations. This is roughly the same procedure as is used for track the -STABLE or
-CURRENT development branches.</p>

<p><tt class=""FILENAME"">/usr/src/UPDATING</tt> contains important information on updating
a FreeBSD system from source code. It lists various issues resulting from changes in
FreeBSD that may affect an upgrade.</p>
</div>
</div>

<div class=""SECT1"">
<hr />
<h2 class=""SECT1""><a id=""TROUBLE"" name=""TROUBLE"">4 Troubleshooting</a></h2>

<div class=""SECT2"">
<h3 class=""SECT2""><a id=""REPAIRING"" name=""REPAIRING"">4.1 Repairing an Existing FreeBSD
Installation</a></h3>

<p>FreeBSD features a ``fixit'' option in the top menu of the <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=sysinstall&sektion=8&manpath=FreeBSD+5.4-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">sysinstall</span>(8)</span></a>
installation program. It provides a shell with common programs from the FreeBSD base
system; this environment is useful for repairing or troubleshooting an existing FreeBSD
installation. To use fixit mode, you will also need either the <tt
class=""FILENAME"">fixit.flp</tt> floppy, generated in the same fashion as the boot
floppies, or the ``live filesystem'' CDROM. In multi-disk FreeBSD distributions, the live
filesystem image is typically located on the installation disk. Note that some UNIX
system administration experience is required to use the fixit option.</p>

<p>Generally, there are two ways of invoking fixit mode. Users who can boot from the
FreeBSD installation CDROM, should do so and then choose the ``fixit'' item from the main
<a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=sysinstall&sektion=8&manpath=FreeBSD+5.4-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">sysinstall</span>(8)</span></a>
menu. Then select the ``CDROM/DVD'' option from the fixit menu.</p>

<p>Users who cannot boot from CDROM, but can boot from floppy disk, require a few more
steps. In addition to the <tt class=""FILENAME"">boot.flp</tt> and <tt
class=""FILENAME"">kern<tt class=""REPLACEABLE""><i>X</i></tt>.flp</tt> disks required for
installation, create the <tt class=""FILENAME"">fixit.flp</tt> floppy disk, in the same way
as the other floppy disks. Follow the instructions for booting the installation program
from floppy disk until reaching the main <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=sysinstall&sektion=8&manpath=FreeBSD+5.4-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">sysinstall</span>(8)</span></a>
menu. At that point, choose the ``fixit'' item from the main <a
href=""http://www.FreeBSD.org/cgi/man.cgi?query=sysinstall&sektion=8&manpath=FreeBSD+5.4-RELEASE"">
<span class=""CITEREFENTRY""><span class=""REFENTRYTITLE"">sysinstall</span>(8)</span></a>
menu. Then select the ``Floppy'' option from the fixit menu, and insert the <tt
class=""FILENAME"">fixit.flp</tt> floppy disk when prompted to do so.</p>

<p>The CDROM and floppy fixit environments are similar, but not identical. Both offer a
shell with a variety of commands available for checking, repairing and examining
filesystems and their contents. The CDROM version of fixit provides all of the commands
and programs available in the FreeBSD base system, through the live filesystem. By
contrast, the floppy fixit environment can only offer a subset of commands due to space
constraints.</p>

<p>In the floppy version of fixit, some standalone utilities can be found in <tt
class=""FILENAME"">/stand</tt> or <tt class=""FILENAME"">/mnt2/stand</tt>. In the CDROM
version of fixit, these same programs can be found in <tt class=""FILENAME"">/stand</tt> or
<tt class=""FILENAME"">/mnt2/rescue</tt> (as well as the rest of the programs from the live
filesystem, which can be found under <tt class=""FILENAME"">/mnt</tt>).</p>
</div>

<div class=""SECT2"">
<hr />
<h3 class=""SECT2""><a id=""AEN844"" name=""AEN844"">4.2 Common Installation Problems for
UltraSPARC Architecture Users</a></h3>
</div>
</div>
</div>

<hr />
<p align=""center""><small>This file, and other release-related documents, can be
downloaded from <a href=""ftp://ftp.FreeBSD.org/"">ftp://ftp.FreeBSD.org/</a>.</small></p>

<p align=""center""><small>For questions about FreeBSD, read the <a
href=""http://www.FreeBSD.org/docs.html"">documentation</a> before contacting &#60;<a
href=""mailto:questions@FreeBSD.org"">questions@FreeBSD.org</a>&#62;.</small></p>

<p align=""center""><small>For questions about this documentation, e-mail &#60;<a
href=""mailto:doc@FreeBSD.org"">doc@FreeBSD.org</a>&#62;.</small></p>
++++


",12272,False,2483.0047957595953,median
"/****************************************************************************
 Copyright (c) 2013      Zynga Inc.
 Copyright (c) 2013-2016 Chukong Technologies Inc.
 Copyright (c) 2017-2018 Xiamen Yaji Software Co., Ltd.

 http://www.cocos2d-x.org

 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 ""2d/CCLabel.h""

#include <algorithm>

#include ""2d/CCFont.h""
#include ""2d/CCFontAtlasCache.h""
#include ""2d/CCFontAtlas.h""
#include ""2d/CCSprite.h""
#include ""2d/CCSpriteBatchNode.h""
#include ""2d/CCDrawNode.h""
#include ""2d/CCCamera.h""
#include ""base/ccUTF8.h""
#include ""platform/CCFileUtils.h""
#include ""renderer/CCRenderer.h""
// #include ""renderer/ccGLStateCache.h""
#include ""renderer/CCGLProgramState.h""
#include ""base/CCDirector.h""
#include ""base/CCEventListenerCustom.h""
#include ""base/CCEventDispatcher.h""
#include ""base/CCEventCustom.h""
#include ""2d/CCFontFNT.h""
#include ""renderer/Texture2DUtils.h""
#include ""Urho3DContext.h""
#include ""renderer/Texture2DUtils.h""
#include ""Urho3DContext.h""
#include ""../../Core/Context.h""
#include ""../../Graphics/Texture2D.h""
#include ""../../Graphics/Graphics.h""

NS_CC_BEGIN

/**
 * LabelLetter used to update the quad in texture atlas without SpriteBatchNode.
 */
class LabelLetter : public Sprite
{
public:
    LabelLetter()
    {
        _textureAtlas = nullptr;
        _letterVisible = true;
    }

    static LabelLetter* createWithTexture(Urho3D::Texture2D* texture, const Rect& rect, bool rotated = false)
    {
        auto letter = new (std::nothrow) LabelLetter();
        if (letter && letter->initWithTexture(texture, rect, rotated))
        {
            letter->Sprite::setVisible(false);
            letter->autorelease();
            return letter;
        }
        CC_SAFE_DELETE(letter);
        return nullptr;
    }
    
    CREATE_FUNC(LabelLetter);

    virtual void updateTransform() override
    {
        if (isDirty())
        {
            _transformToBatch = getNodeToParentTransform();
            Size &size = _rect.size;

            float x1 = _offsetPosition.x;
            float y1 = _offsetPosition.y;
            float x2 = x1 + size.width;
            float y2 = y1 + size.height;

            // issue #17022: don't flip, again, the letter since they are flipped in sprite's code
            //if (_flippedX) std::swap(x1, x2);
            //if (_flippedY) std::swap(y1, y2);

            float x = _transformToBatch.m[12];
            float y = _transformToBatch.m[13];

            float cr = _transformToBatch.m[0];
            float sr = _transformToBatch.m[1];
            float cr2 = _transformToBatch.m[5];
            float sr2 = -_transformToBatch.m[4];
            float ax = x1 * cr - y1 * sr2 + x;
            float ay = x1 * sr + y1 * cr2 + y;

            float bx = x2 * cr - y1 * sr2 + x;
            float by = x2 * sr + y1 * cr2 + y;
            float cx = x2 * cr - y2 * sr2 + x;
            float cy = x2 * sr + y2 * cr2 + y;
            float dx = x1 * cr - y2 * sr2 + x;
            float dy = x1 * sr + y2 * cr2 + y;

            _quad.bl.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(ax), SPRITE_RENDER_IN_SUBPIXEL(ay), _positionZ);
            _quad.br.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(bx), SPRITE_RENDER_IN_SUBPIXEL(by), _positionZ);
            _quad.tl.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(dx), SPRITE_RENDER_IN_SUBPIXEL(dy), _positionZ);
            _quad.tr.vertices.set(SPRITE_RENDER_IN_SUBPIXEL(cx), SPRITE_RENDER_IN_SUBPIXEL(cy), _positionZ);

            if (_textureAtlas)
            {
                _textureAtlas->updateQuad(&_quad, _atlasIndex);
            }

            _recursiveDirty = false;
            setDirty(false);
        }

        Node::updateTransform();
    }

    virtual void updateColor() override
    {
        if (_textureAtlas == nullptr)
        {
            return;
        }

        auto displayedOpacity = _displayedOpacity;
        if(!_letterVisible)
        {
            displayedOpacity = 0.0f;
        }
        Color4B color4(_displayedColor.r, _displayedColor.g, _displayedColor.b, displayedOpacity);
        // special opacity for premultiplied textures
        if (_opacityModifyRGB)
        {
            color4.r *= displayedOpacity / 255.0f;
            color4.g *= displayedOpacity / 255.0f;
            color4.b *= displayedOpacity / 255.0f;
        }
        _quad.bl.colors = color4;
        _quad.br.colors = color4;
        _quad.tl.colors = color4;
        _quad.tr.colors = color4;

        _textureAtlas->updateQuad(&_quad, _atlasIndex);
    }

    void setVisible(bool visible) override
    {
        _letterVisible = visible;
        updateColor();
    }

    bool isVisible() const override
    {
        return _letterVisible;
    }
    
    //LabelLetter doesn't need to draw directly.
    void draw(Renderer* /*renderer*/, const Mat4 & /*transform*/, uint32_t /*flags*/) override
    {
    }
    
private:
    bool _letterVisible;
};

Label* Label::create()
{
    auto ret = new (std::nothrow) Label;

    if (ret)
    {
        ret->autorelease();
    }

    return ret;
}

Label* Label::create(const std::string& text, const std::string& font, float fontSize, const Size& dimensions /* = Size::ZERO */, TextHAlignment hAlignment /* = TextHAlignment::LEFT */, TextVAlignment vAlignment /* = TextVAlignment::TOP */)
{
    if (FileUtils::getInstance()->isFileExist(font))
    {
        return createWithTTF(text,font,fontSize,dimensions,hAlignment,vAlignment);
    } 
    else
    {
        return createWithSystemFont(text,font,fontSize,dimensions,hAlignment,vAlignment);
    }
}

Label* Label::createWithSystemFont(const std::string& text, const std::string& font, float fontSize, const Size& dimensions /* = Size::ZERO */, TextHAlignment hAlignment /* = TextHAlignment::LEFT */, TextVAlignment vAlignment /* = TextVAlignment::TOP */)
{
    auto ret = new (std::nothrow) Label(hAlignment,vAlignment);

    if (ret)
    {
        ret->setSystemFontName(font);
        ret->setSystemFontSize(fontSize);
        ret->setDimensions(dimensions.width, dimensions.height);
        ret->setString(text);

        ret->autorelease();

        return ret;
    }

    return nullptr;
}

Label* Label::createWithTTF(const std::string& text, const std::string& fontFile, float fontSize, const Size& dimensions /* = Size::ZERO */, TextHAlignment hAlignment /* = TextHAlignment::LEFT */, TextVAlignment vAlignment /* = TextVAlignment::TOP */)
{
    auto ret = new (std::nothrow) Label(hAlignment,vAlignment);

    if (ret && ret->initWithTTF(text, fontFile, fontSize, dimensions, hAlignment, vAlignment))
    {
        ret->autorelease();
        return ret;
    }

    CC_SAFE_DELETE(ret);
    return nullptr;
}

Label* Label::createWithTTF(const TTFConfig& ttfConfig, const std::string& text, TextHAlignment hAlignment /* = TextHAlignment::CENTER */, int maxLineWidth /* = 0 */)
{
    auto ret = new (std::nothrow) Label(hAlignment);

    if (ret && ret->initWithTTF(ttfConfig, text, hAlignment, maxLineWidth))
    {
        ret->autorelease();
        return ret;
    }

    CC_SAFE_DELETE(ret);
    return nullptr;
}

Label* Label::createWithBMFont(const std::string& bmfontFilePath, const std::string& text,const TextHAlignment& hAlignment /* = TextHAlignment::LEFT */, int maxLineWidth /* = 0 */, const Vec2& imageOffset /* = Vec2::ZERO */)
{
    auto ret = new (std::nothrow) Label(hAlignment);

    if (ret && ret->setBMFontFilePath(bmfontFilePath,imageOffset))
    {
        ret->setMaxLineWidth(maxLineWidth);
        ret->setString(text);
        ret->autorelease();

        return ret;
    }
    
    delete ret;
    return nullptr;
}

Label* Label::createWithCharMap(const std::string& plistFile)
{
    auto ret = new (std::nothrow) Label();

    if (ret && ret->setCharMap(plistFile))
    {
        ret->autorelease();
        return ret;
    }

    delete ret;
    return nullptr;
}

Label* Label::createWithCharMap(Urho3D::Texture2D* texture, int itemWidth, int itemHeight, int startCharMap)
{
    auto ret = new (std::nothrow) Label();

    if (ret && ret->setCharMap(texture,itemWidth,itemHeight,startCharMap))
    {
        ret->autorelease();
        return ret;
    }

    delete ret;
    return nullptr;
}

Label* Label::createWithCharMap(const std::string& charMapFile, int itemWidth, int itemHeight, int startCharMap)
{
    auto ret = new (std::nothrow) Label();

    if (ret && ret->setCharMap(charMapFile,itemWidth,itemHeight,startCharMap))
    {
        ret->autorelease();
        return ret;
    }

    delete ret;
    return nullptr;
}

bool Label::setCharMap(const std::string& plistFile)
{
    auto newAtlas = FontAtlasCache::getFontAtlasCharMap(plistFile);

    if (!newAtlas)
    {
        reset();
        return false;
    }

    _currentLabelType = LabelType::CHARMAP;
    setFontAtlas(newAtlas);

    return true;
}


bool Label::initWithTTF(const std::string& text,
                        const std::string& fontFilePath, float fontSize,
                        const Size& dimensions,
                        TextHAlignment /*hAlignment*/, TextVAlignment /*vAlignment*/)
{
    if (FileUtils::getInstance()->isFileExist(fontFilePath))
    {
        TTFConfig ttfConfig(fontFilePath, fontSize, GlyphCollection::DYNAMIC);
        if (setTTFConfig(ttfConfig))
        {
            setDimensions(dimensions.width, dimensions.height);
            setString(text);
        }
        return true;
    }
    return false;
}

bool Label::initWithTTF(const TTFConfig& ttfConfig, const std::string& text, TextHAlignment /*hAlignment*/, int maxLineWidth)
{
    if (FileUtils::getInstance()->isFileExist(ttfConfig.fontFilePath) && setTTFConfig(ttfConfig))
    {
        setMaxLineWidth(maxLineWidth);
        setString(text);
        return true;
    }
    return false;
}

bool Label::setCharMap(Urho3D::Texture2D* texture, int itemWidth, int itemHeight, int startCharMap)
{
    auto newAtlas = FontAtlasCache::getFontAtlasCharMap(texture,itemWidth,itemHeight,startCharMap);

    if (!newAtlas)
    {
        reset();
        return false;
    }

    _currentLabelType = LabelType::CHARMAP;
    setFontAtlas(newAtlas);

    return true;
}

bool Label::setCharMap(const std::string& charMapFile, int itemWidth, int itemHeight, int startCharMap)
{
    auto newAtlas = FontAtlasCache::getFontAtlasCharMap(charMapFile,itemWidth,itemHeight,startCharMap);

    if (!newAtlas)
    {
        reset();
        return false;
    }

    _currentLabelType = LabelType::CHARMAP;
    setFontAtlas(newAtlas);

    return true;
}

Label::Label(TextHAlignment hAlignment /* = TextHAlignment::LEFT */, 
             TextVAlignment vAlignment /* = TextVAlignment::TOP */)
: _textSprite(nullptr)
, _shadowNode(nullptr)
, _fontAtlas(nullptr)
, _reusedLetter(nullptr)
, _horizontalKernings(nullptr)
, _boldEnabled(false)
, _underlineNode(nullptr)
, _strikethroughEnabled(false)
{
    setAnchorPoint(Vec2::ANCHOR_MIDDLE);
    reset();
    _hAlignment = hAlignment;
    _vAlignment = vAlignment;

#if CC_LABEL_DEBUG_DRAW
    _debugDrawNode = DrawNode::create();
    addChild(_debugDrawNode);
#endif

    _purgeTextureListener = EventListenerCustom::create(FontAtlas::CMD_PURGE_FONTATLAS, [this](EventCustom* event){
        if (_fontAtlas && _currentLabelType == LabelType::TTF && event->getUserData() == _fontAtlas)
        {
            for (auto&& it : _letters)
            {
                it.second->setTexture(nullptr);
            }
            _batchNodes.clear();

            if (_fontAtlas)
            {
                FontAtlasCache::releaseFontAtlas(_fontAtlas);
            }
        }
    });
    _eventDispatcher->addEventListenerWithFixedPriority(_purgeTextureListener, 1);
    
    _resetTextureListener = EventListenerCustom::create(FontAtlas::CMD_RESET_FONTATLAS, [this](EventCustom* event){
        if (_fontAtlas && _currentLabelType == LabelType::TTF && event->getUserData() == _fontAtlas)
        {
            _fontAtlas = nullptr;
            auto lineHeight = _lineHeight;
            this->setTTFConfig(_fontConfig);
            if (_currentLabelType != LabelType::STRING_TEXTURE)
            {
                setLineHeight(lineHeight);
            }
            for (auto&& it : _letters)
            {
                getLetter(it.first);
            }
        }
    });
    _eventDispatcher->addEventListenerWithFixedPriority(_resetTextureListener, 2);
}

Label::~Label()
{
    delete [] _horizontalKernings;

    if (_fontAtlas)
    {
        Node::removeAllChildrenWithCleanup(true);
        CC_SAFE_RELEASE_NULL(_reusedLetter);
        _batchNodes.clear();
        FontAtlasCache::releaseFontAtlas(_fontAtlas);
    }
    _eventDispatcher->removeEventListener(_purgeTextureListener);
    _eventDispatcher->removeEventListener(_resetTextureListener);

    CC_SAFE_RELEASE_NULL(_textSprite);
    CC_SAFE_RELEASE_NULL(_shadowNode);
}

void Label::reset()
{
    CC_SAFE_RELEASE_NULL(_textSprite);
    CC_SAFE_RELEASE_NULL(_shadowNode);
    Node::removeAllChildrenWithCleanup(true);
    CC_SAFE_RELEASE_NULL(_reusedLetter);
    _letters.clear();
    _batchNodes.clear();
    _lettersInfo.clear();
    if (_fontAtlas)
    {
        FontAtlasCache::releaseFontAtlas(_fontAtlas);
        _fontAtlas = nullptr;
    }

    _currentLabelType = LabelType::STRING_TEXTURE;
    _currLabelEffect = LabelEffect::NORMAL;
    _contentDirty = false;
    _numberOfLines = 0;
    _lengthOfString = 0;
    _utf32Text.clear();
    _utf8Text.clear();

    TTFConfig temp;
    _fontConfig = temp;
    _outlineSize = 0.f;
    _bmFontPath = """";
    _systemFontDirty = false;
    _systemFont = ""Helvetica"";
    _systemFontSize = CC_DEFAULT_FONT_LABEL_SIZE;

    if (_horizontalKernings)
    {
        delete[] _horizontalKernings;
        _horizontalKernings = nullptr;
    }
    _additionalKerning = 0.f;
    _lineHeight = 0.f;
    _lineSpacing = 0.f;
    _maxLineWidth = 0.f;
    _labelDimensions.width = 0.f;
    _labelDimensions.height = 0.f;
    _labelWidth = 0.f;
    _labelHeight = 0.f;
    _lineBreakWithoutSpaces = false;
    _hAlignment = TextHAlignment::LEFT;
    _vAlignment = TextVAlignment::TOP;

    _effectColorF = Color4F::BLACK;
    _textColor = Color4B::WHITE;
    _textColorF = Color4F::WHITE;
    setColor(Color3B::WHITE);

    _shadowDirty = false;
    _shadowEnabled = false;
    _shadowBlurRadius = 0.f;

//     _uniformEffectColor = -1;
//     _uniformEffectType = -1;
//     _uniformTextColor = -1;

    _useDistanceField = false;
    _useA8Shader = false;
    _clipEnabled = false;
    _blendFuncDirty = false;
    _blendFunc = BlendFunc::ALPHA_PREMULTIPLIED;
    _isOpacityModifyRGB = false;
    _insideBounds = true;
    _enableWrap = true;
    _bmFontSize = -1;
    _bmfontScale = 1.0f;
    _overflow = Overflow::NONE;
    _originalFontSize = 0.0f;
    _boldEnabled = false;
    if (_underlineNode)
    {
        removeChild(_underlineNode);
        _underlineNode = nullptr;
    }
    _strikethroughEnabled = false;
    setRotationSkewX(0);        // reverse italics
}

//  ETC1 ALPHA supports, for LabelType::BMFONT & LabelType::CHARMAP
static Urho3D::Texture2D* _getTexture(Label* label)
{
    auto fontAtlas = label->getFontAtlas();
    Urho3D::Texture2D* texture = nullptr;
    if (fontAtlas != nullptr) {
        auto textures = fontAtlas->getTextures();
        if(!textures.empty()) {
            texture = textures.begin()->second;
        }
    }
    return texture;
}

void Label::updateShaderProgram()
{
    switch (_currLabelEffect)
    {
    case cocos2d::LabelEffect::NORMAL:
        if (_useDistanceField)
            setGLProgramState(GLProgramState::getOrCreateWithGLProgramName(GLProgram::SHADER_NAME_LABEL_DISTANCEFIELD_NORMAL));
        else if (_useA8Shader)
            setGLProgramState(GLProgramState::getOrCreateWithGLProgramName(GLProgram::SHADER_NAME_LABEL_NORMAL));
        else if (_shadowEnabled)
            setGLProgramState(GLProgramState::getOrCreateWithGLProgramName(GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR, _getTexture(this)));
        else
            setGLProgramState(GLProgramState::getOrCreateWithGLProgramName(GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR_NO_MVP, _getTexture(this)));

        break;
    case cocos2d::LabelEffect::OUTLINE: 
        setGLProgramState(GLProgramState::getOrCreateWithGLProgramName(GLProgram::SHADER_NAME_LABEL_OUTLINE));
        //_uniformEffectColor = glGetUniformLocation(getGLProgram()->getProgram(), ""u_effectColor"");
        //_uniformEffectType = glGetUniformLocation(getGLProgram()->getProgram(), ""u_effectType"");
        break;
    case cocos2d::LabelEffect::GLOW:
        if (_useDistanceField)
        {
            setGLProgramState(GLProgramState::getOrCreateWithGLProgramName(GLProgram::SHADER_NAME_LABEL_DISTANCEFIELD_GLOW));
            //_uniformEffectColor = glGetUniformLocation(getGLProgram()->getProgram(), ""u_effectColor"");
        }
        break;
    default:
        return;
    }
    
    //_uniformTextColor = glGetUniformLocation(getGLProgram()->getProgram(), ""u_textColor"");
}

void Label::setFontAtlas(FontAtlas* atlas,bool distanceFieldEnabled /* = false */, bool useA8Shader /* = false */)
{
    if(atlas)
    {
        _systemFontDirty = false;
    }

    if (atlas == _fontAtlas)
        return;

    CC_SAFE_RETAIN(atlas);
    if (_fontAtlas)
    {
        _batchNodes.clear();
        FontAtlasCache::releaseFontAtlas(_fontAtlas);
    }
    _fontAtlas = atlas;
    
    if (_reusedLetter == nullptr)
    {
        _reusedLetter = Sprite::create();
        _reusedLetter->setOpacityModifyRGB(_isOpacityModifyRGB);            
        _reusedLetter->retain();
        _reusedLetter->setAnchorPoint(Vec2::ANCHOR_TOP_LEFT);
    }

    if (_fontAtlas)
    {
        _lineHeight = _fontAtlas->getLineHeight();
        _contentDirty = true;
        _systemFontDirty = false;
    }
    _useDistanceField = distanceFieldEnabled;
    _useA8Shader = useA8Shader;

    if (_currentLabelType != LabelType::TTF)
    {
        _currLabelEffect = LabelEffect::NORMAL;
        updateShaderProgram();
    }
}

bool Label::setTTFConfig(const TTFConfig& ttfConfig)
{
    _originalFontSize = ttfConfig.fontSize;
    return setTTFConfigInternal(ttfConfig);
}

bool Label::setBMFontFilePath(const std::string& bmfontFilePath, const Vec2& imageOffset, float fontSize)
{
    FontAtlas *newAtlas = FontAtlasCache::getFontAtlasFNT(bmfontFilePath,imageOffset);
    
    if (!newAtlas)
    {
        reset();
        return false;
    }

    //assign the default fontSize
    if (std::abs(fontSize) < FLT_EPSILON) {
        FontFNT *bmFont = (FontFNT*)newAtlas->getFont();
        if (bmFont) {
            float originalFontSize = bmFont->getOriginalFontSize();
            _bmFontSize = originalFontSize / CC_CONTENT_SCALE_FACTOR();
        }
    }

    if(fontSize > 0.0f){
        _bmFontSize = fontSize;
    }

    _bmFontPath = bmfontFilePath;

    _currentLabelType = LabelType::BMFONT;
    setFontAtlas(newAtlas);

    return true;
}

void Label::setString(const std::string& text)
{
    if (text.compare(_utf8Text))
    {
        _utf8Text = text;
        _contentDirty = true;

        std::u32string utf32String;
        if (StringUtils::UTF8ToUTF32(_utf8Text, utf32String))
        {
            _utf32Text  = utf32String;
        }

        CCASSERT(_utf32Text.length() <= CC_LABEL_MAX_LENGTH, ""Length of text should be less then 16384"");
        if (_utf32Text.length() > CC_LABEL_MAX_LENGTH)
        {
            cocos2d::log(""Error: Label text is too long %d > %d and it will be truncated!"", _utf32Text.length(), CC_LABEL_MAX_LENGTH);
            _utf32Text = _utf32Text.substr(0, CC_LABEL_MAX_LENGTH);
        }
    }
}

void Label::setAlignment(TextHAlignment hAlignment,TextVAlignment vAlignment)
{
    if (hAlignment != _hAlignment || vAlignment != _vAlignment)
    {
        _hAlignment = hAlignment;
        _vAlignment = vAlignment;

        _contentDirty = true;
    }
}

void Label::setMaxLineWidth(float maxLineWidth)
{
    if (_labelWidth == 0 && _maxLineWidth != maxLineWidth)
    {
        _maxLineWidth = maxLineWidth;
        _contentDirty = true;
    }
}

void Label::setDimensions(float width, float height)
{
    if(_overflow == Overflow::RESIZE_HEIGHT){
        height = 0;
    }
    if (height != _labelHeight || width != _labelWidth)
    {
        _labelWidth = width;
        _labelHeight = height;
        _labelDimensions.width = width;
        _labelDimensions.height = height;

        _maxLineWidth = width;
        _contentDirty = true;

        if(_overflow == Overflow::SHRINK){
            if (_originalFontSize > 0) {
                this->restoreFontSize();
            }
        }
    }
}

void Label::restoreFontSize()
{
    if(_currentLabelType == LabelType::TTF){
        auto ttfConfig = this->getTTFConfig();
        ttfConfig.fontSize = _originalFontSize;
        this->setTTFConfigInternal(ttfConfig);
    }else if(_currentLabelType == LabelType::BMFONT){
        this->setBMFontSizeInternal(_originalFontSize);
    }else if(_currentLabelType == LabelType::STRING_TEXTURE){
        this->setSystemFontSize(_originalFontSize);
    }
}

void Label::setLineBreakWithoutSpace(bool breakWithoutSpace)
{
    if (breakWithoutSpace != _lineBreakWithoutSpaces)
    {
        _lineBreakWithoutSpaces = breakWithoutSpace;
        _contentDirty = true;     
    }
}

void Label::updateLabelLetters()
{
    if (!_letters.empty())
    {
        Rect uvRect;
        LabelLetter* letterSprite;
        int letterIndex;

        for (auto it = _letters.begin(); it != _letters.end();)
        {
            letterIndex = it->first;
            letterSprite = (LabelLetter*)it->second;

            if (letterIndex >= _lengthOfString)
            {
                Node::removeChild(letterSprite, true);
                it = _letters.erase(it);
            }
            else
            {
                auto& letterInfo = _lettersInfo[letterIndex];
                if (letterInfo.valid)
                {
                    auto& letterDef = _fontAtlas->_letterDefinitions[letterInfo.utf32Char];
                    uvRect.size.height = letterDef.height;
                    uvRect.size.width = letterDef.width;
                    uvRect.origin.x = letterDef.U;
                    uvRect.origin.y = letterDef.V;

                    auto batchNode = _batchNodes.at(letterDef.textureID);
                    letterSprite->setTextureAtlas(batchNode->getTextureAtlas());
                    letterSprite->setTexture(_fontAtlas->getTexture(letterDef.textureID));
                    if (letterDef.width <= 0.f || letterDef.height <= 0.f)
                    {
                        letterSprite->setTextureAtlas(nullptr);
                    }
                    else
                    {
                        letterSprite->setTextureRect(uvRect, false, uvRect.size);
                        letterSprite->setTextureAtlas(_batchNodes.at(letterDef.textureID)->getTextureAtlas());
                        letterSprite->setAtlasIndex(_lettersInfo[letterIndex].atlasIndex);
                    }

                    auto px = letterInfo.positionX + letterDef.width / 2 + _linesOffsetX[letterInfo.lineIndex];
                    auto py = letterInfo.positionY - letterDef.height / 2 + _letterOffsetY;
                    letterSprite->setPosition(px, py);
                }
                else
                {
                    letterSprite->setTextureAtlas(nullptr);
                }
                this->updateLetterSpriteScale(letterSprite);
                ++it;
            }
        }
    }
}

bool Label::alignText()
{
    if (_fontAtlas == nullptr || _utf32Text.empty())
    {
        setContentSize(Size::ZERO);
        return true;
    }

    bool ret = true;
    do {
        _fontAtlas->prepareLetterDefinitions(_utf32Text);
        auto& textures = _fontAtlas->getTextures();
        auto size = textures.size();
        if (size > static_cast<size_t>(_batchNodes.size()))
        {
            for (auto index = static_cast<size_t>(_batchNodes.size()); index < size; ++index)
            {
                auto batchNode = SpriteBatchNode::createWithTexture(textures.at(index));
                if (batchNode)
                {
                    _isOpacityModifyRGB = false;// batchNode->getTexture()->hasPremultipliedAlpha();
                    _blendFunc = batchNode->getBlendFunc();
                    batchNode->setAnchorPoint(Vec2::ANCHOR_TOP_LEFT);
                    batchNode->setPosition(Vec2::ZERO);
                    _batchNodes.pushBack(batchNode);
                }
            }
        }
        if (_batchNodes.empty())
        {
            return true;
        }
        // optimize for one-texture-only scenario
        // if multiple textures, then we should count how many chars
        // are per texture
        if (_batchNodes.size()==1)
            _batchNodes.at(0)->reserveCapacity(_utf32Text.size());

        _reusedLetter->setBatchNode(_batchNodes.at(0));
        
        _lengthOfString = 0;
        _textDesiredHeight = 0.f;
        _linesWidth.clear();
        if (_maxLineWidth > 0.f && !_lineBreakWithoutSpaces)
        {
            multilineTextWrapByWord();
        }
        else
        {
            multilineTextWrapByChar();
        }
        computeAlignmentOffset();

        if(_overflow == Overflow::SHRINK){
            float fontSize = this->getRenderingFontSize();

            if(fontSize > 0 &&  isVerticalClamp()){
                this->shrinkLabelToContentSize(CC_CALLBACK_0(Label::isVerticalClamp, this));
            }
        }

        if(!updateQuads()){
            ret = false;
            if(_overflow == Overflow::SHRINK){
                this->shrinkLabelToContentSize(CC_CALLBACK_0(Label::isHorizontalClamp, this));
            }
            break;
        }
    
        updateLabelLetters();
        
        updateColor();
    }while (0);

    return ret;
}

bool Label::computeHorizontalKernings(const std::u32string& stringToRender)
{
    if (_horizontalKernings)
    {
        delete [] _horizontalKernings;
        _horizontalKernings = nullptr;
    }

    int letterCount = 0;
    _horizontalKernings = _fontAtlas->getFont()->getHorizontalKerningForTextUTF32(stringToRender, letterCount);

    if(!_horizontalKernings)
        return false;
    else
        return true;
}

bool Label::isHorizontalClamped(float letterPositionX, int lineIndex)
{
    auto wordWidth = this->_linesWidth[lineIndex];
    bool letterOverClamp = (letterPositionX > _contentSize.width || letterPositionX < 0);
    if (!_enableWrap) {
        return letterOverClamp;
    }else{
        return (wordWidth > this->_contentSize.width && letterOverClamp);
    }
}

bool Label::updateQuads()
{
    bool ret = true;
    for (auto&& batchNode : _batchNodes)
    {
        batchNode->getTextureAtlas()->removeAllQuads();
    }
    
    for (int ctr = 0; ctr < _lengthOfString; ++ctr)
    {
        if (_lettersInfo[ctr].valid)
        {
            auto& letterDef = _fontAtlas->_letterDefinitions[_lettersInfo[ctr].utf32Char];
            
            _reusedRect.size.height = letterDef.height;
            _reusedRect.size.width  = letterDef.width;
            _reusedRect.origin.x    = letterDef.U;
            _reusedRect.origin.y    = letterDef.V;

            auto py = _lettersInfo[ctr].positionY + _letterOffsetY;
            if (_labelHeight > 0.f) {
                if (py > _tailoredTopY)
                {
                    auto clipTop = py - _tailoredTopY;
                    _reusedRect.origin.y += clipTop;
                    _reusedRect.size.height -= clipTop;
                    py -= clipTop;
                }
                if (py - letterDef.height * _bmfontScale < _tailoredBottomY)
                {
                    _reusedRect.size.height = (py < _tailoredBottomY) ? 0.f : (py - _tailoredBottomY);
                }
            }

            auto lineIndex = _lettersInfo[ctr].lineIndex;
            auto px = _lettersInfo[ctr].positionX + letterDef.width/2 * _bmfontScale + _linesOffsetX[lineIndex];

            if(_labelWidth > 0.f){
                if (this->isHorizontalClamped(px, lineIndex)) {
                    if(_overflow == Overflow::CLAMP){
                        _reusedRect.size.width = 0;
                    }else if(_overflow == Overflow::SHRINK){
                        if (_contentSize.width > letterDef.width) {
                            ret = false;
                            break;
                        }else{
                            _reusedRect.size.width = 0;
                        }

                    }
                }
            }


            if (_reusedRect.size.height > 0.f && _reusedRect.size.width > 0.f)
            {
                _reusedLetter->setTextureRect(_reusedRect, false, _reusedRect.size);
                float letterPositionX = _lettersInfo[ctr].positionX + _linesOffsetX[_lettersInfo[ctr].lineIndex];
                _reusedLetter->setPosition(letterPositionX, py);
                auto index = static_cast<int>(_batchNodes.at(letterDef.textureID)->getTextureAtlas()->getTotalQuads());
                _lettersInfo[ctr].atlasIndex = index;

                this->updateLetterSpriteScale(_reusedLetter);

                _batchNodes.at(letterDef.textureID)->insertQuadFromSprite(_reusedLetter, index);
            }
        }     
    }


    return ret;
}

bool Label::setTTFConfigInternal(const TTFConfig& ttfConfig)
{
    FontAtlas *newAtlas = FontAtlasCache::getFontAtlasTTF(&ttfConfig);

    if (!newAtlas)
    {
        reset();
        return false;
    }

    _currentLabelType = LabelType::TTF;
    setFontAtlas(newAtlas,ttfConfig.distanceFieldEnabled,true);

    _fontConfig = ttfConfig;

    if (_fontConfig.outlineSize > 0)
    {
        _fontConfig.distanceFieldEnabled = false;
        _useDistanceField = false;
        _useA8Shader = false;
        _currLabelEffect = LabelEffect::OUTLINE;
        updateShaderProgram();
    }
    else
    {
        _currLabelEffect = LabelEffect::NORMAL;
        updateShaderProgram();
    }

    if (_fontConfig.italics)
        this->enableItalics();
    if (_fontConfig.bold)
        this->enableBold();
    if (_fontConfig.underline)
        this->enableUnderline();
    if (_fontConfig.strikethrough)
        this->enableStrikethrough();

    return true;
}

void Label::setBMFontSizeInternal(float fontSize)
{
    if(_currentLabelType == LabelType::BMFONT){
        this->setBMFontFilePath(_bmFontPath, Vec2::ZERO, fontSize);
        _contentDirty = true;
    }
}

void Label::scaleFontSizeDown(float fontSize)
{
    bool shouldUpdateContent = true;
    if(_currentLabelType == LabelType::TTF){
        auto ttfConfig = this->getTTFConfig();
        ttfConfig.fontSize = fontSize;
        this->setTTFConfigInternal(ttfConfig);
    }else if(_currentLabelType == LabelType::BMFONT){
        if (std::abs(fontSize) < FLT_EPSILON) {
            fontSize = 0.1f;
            shouldUpdateContent = false;
        }
        this->setBMFontSizeInternal(fontSize);
    }else if (_currentLabelType == LabelType::STRING_TEXTURE){
        this->setSystemFontSize(fontSize);
    }
    
    if (shouldUpdateContent) {
        this->updateContent();
    }
}

void Label::enableGlow(const Color4B& glowColor)
{
    if (_currentLabelType == LabelType::TTF)
    {
        if (_fontConfig.distanceFieldEnabled == false)
        {
            auto config = _fontConfig;
            config.outlineSize = 0;
            config.distanceFieldEnabled = true;
            setTTFConfig(config);
            _contentDirty = true;
        }
        _currLabelEffect = LabelEffect::GLOW;
        _effectColorF.r = glowColor.r / 255.0f;
        _effectColorF.g = glowColor.g / 255.0f;
        _effectColorF.b = glowColor.b / 255.0f;
        _effectColorF.a = glowColor.a / 255.0f;
        updateShaderProgram();
    }
}

void Label::enableOutline(const Color4B& outlineColor,int outlineSize /* = -1 */)
{
    CCASSERT(_currentLabelType == LabelType::STRING_TEXTURE || _currentLabelType == LabelType::TTF, ""Only supported system font and TTF!"");

    if (outlineSize > 0 || _currLabelEffect == LabelEffect::OUTLINE)
    {
        if (_currentLabelType == LabelType::TTF)
        {
            _effectColorF.r = outlineColor.r / 255.0f;
            _effectColorF.g = outlineColor.g / 255.0f;
            _effectColorF.b = outlineColor.b / 255.0f;
            _effectColorF.a = outlineColor.a / 255.0f;

            if (outlineSize > 0 && _fontConfig.outlineSize != outlineSize)
            {
                _fontConfig.outlineSize = outlineSize;
                setTTFConfig(_fontConfig);
            }
        }
        else if (_effectColorF != outlineColor || _outlineSize != outlineSize)
        {
            _effectColorF.r = outlineColor.r / 255.f;
            _effectColorF.g = outlineColor.g / 255.f;
            _effectColorF.b = outlineColor.b / 255.f;
            _effectColorF.a = outlineColor.a / 255.f;
            _currLabelEffect = LabelEffect::OUTLINE;
            _contentDirty = true;
        }
        _outlineSize = outlineSize;
    }
}

void Label::enableShadow(const Color4B& shadowColor /* = Color4B::BLACK */,
                         const Size &offset /* = Size(2 ,-2)*/,
                         int /* blurRadius = 0 */)
{
    _shadowEnabled = true;
    _shadowDirty = true;

    _shadowOffset.width = offset.width;
    _shadowOffset.height = offset.height;
    //TODO: support blur for shadow

    _shadowColor3B.r = shadowColor.r;
    _shadowColor3B.g = shadowColor.g;
    _shadowColor3B.b = shadowColor.b;
    _shadowOpacity = shadowColor.a;

    if (!_systemFontDirty && !_contentDirty && _textSprite)
    {
        auto fontDef = _getFontDefinition();
        if (_shadowNode)
        {
            if (shadowColor != _shadowColor4F)
            {
                _shadowNode->release();
                _shadowNode = nullptr;
                createShadowSpriteForSystemFont(fontDef);
            }
            else
            {
                _shadowNode->setPosition(_shadowOffset.width, _shadowOffset.height);
            }
        }
        else
        {
            createShadowSpriteForSystemFont(fontDef);
        }
    }

    _shadowColor4F.r = shadowColor.r / 255.0f;
    _shadowColor4F.g = shadowColor.g / 255.0f;
    _shadowColor4F.b = shadowColor.b / 255.0f;
    _shadowColor4F.a = shadowColor.a / 255.0f;

    if (_currentLabelType == LabelType::BMFONT || _currentLabelType == LabelType::CHARMAP)
    {
        setGLProgramState(GLProgramState::getOrCreateWithGLProgramName(_shadowEnabled ? GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR : GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR_NO_MVP, _getTexture(this)));
    }
}

void Label::enableItalics()
{
    setRotationSkewX(12);
}

void Label::enableBold()
{
    if (!_boldEnabled)
    {
        // bold is implemented with outline
        enableShadow(Color4B::WHITE, Size(0.9f, 0), 0);
        // add one to kerning
        setAdditionalKerning(_additionalKerning+1);
        _boldEnabled = true;
    }
}

void Label::enableUnderline()
{
    // remove it, just in case to prevent adding two or more
    if (!_underlineNode)
    {
        _underlineNode = DrawNode::create();
        addChild(_underlineNode, 100000);
        _contentDirty = true;
    }
}

void Label::enableStrikethrough()
{
    if (!_strikethroughEnabled)
    {
        enableUnderline();
        _strikethroughEnabled = true;
    }
}

void Label::disableEffect()
{
    disableEffect(LabelEffect::ALL);
}

void Label::disableEffect(LabelEffect effect)
{
    switch (effect)
    {
        case cocos2d::LabelEffect::NORMAL:
            break;
        case cocos2d::LabelEffect::OUTLINE:
            if (_currLabelEffect == LabelEffect::OUTLINE)
            {
                if (_currentLabelType == LabelType::TTF)
                {
                    _fontConfig.outlineSize = 0;
                    setTTFConfig(_fontConfig);
                }
                _currLabelEffect = LabelEffect::NORMAL;
                _contentDirty = true;
            }
            break;
        case cocos2d::LabelEffect::SHADOW:
            if (_shadowEnabled)
            {
                _shadowEnabled = false;
                CC_SAFE_RELEASE_NULL(_shadowNode);
                updateShaderProgram();
            }
            break;
        case cocos2d::LabelEffect::GLOW:
            if (_currLabelEffect == LabelEffect::GLOW)
            {
                _currLabelEffect = LabelEffect::NORMAL;
                updateShaderProgram();
            }
            break;
        case cocos2d::LabelEffect::ITALICS:
            setRotationSkewX(0);
            break;
        case cocos2d::LabelEffect::BOLD:
            if (_boldEnabled) {
                _boldEnabled = false;
                _additionalKerning -= 1;
                disableEffect(LabelEffect::SHADOW);
            }
            break;
        case cocos2d::LabelEffect::UNDERLINE:
            if (_underlineNode) {
                removeChild(_underlineNode);
                _underlineNode = nullptr;
            }
            break;
        case cocos2d::LabelEffect::STRIKETHROUGH:
            _strikethroughEnabled = false;
            // since it is based on underline, disable it as well
            disableEffect(LabelEffect::UNDERLINE);
            break;
        case LabelEffect::ALL:
        {
            disableEffect(LabelEffect::SHADOW);
            disableEffect(LabelEffect::GLOW);
            disableEffect(LabelEffect::OUTLINE);
            disableEffect(LabelEffect::ITALICS);
            disableEffect(LabelEffect::BOLD);
            disableEffect(LabelEffect::UNDERLINE);
            disableEffect(LabelEffect::STRIKETHROUGH);
        }
            break;
        default:
            break;
    }
}

void Label::createSpriteForSystemFont(const FontDefinition& fontDef)
{
    _currentLabelType = LabelType::STRING_TEXTURE;

    auto texture = new (std::nothrow) Urho3D::Texture2D(GetUrho3DContext());
    /*texture->i*/InitWithString(texture, _utf8Text.c_str(), fontDef);

    _textSprite = Sprite::createWithTexture(texture);
    //set camera mask using label's camera mask, because _textSprite may be null when setting camera mask to label
    _textSprite->setCameraMask(getCameraMask());
    _textSprite->setGlobalZOrder(getGlobalZOrder());
    _textSprite->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
    this->setContentSize(_textSprite->getContentSize());
    //texture->release();
    if (_blendFuncDirty)
    {
        _textSprite->setBlendFunc(_blendFunc);
    }

    //_textSprite->retain();
    _textSprite->updateDisplayedColor(_displayedColor);
    _textSprite->updateDisplayedOpacity(_displayedOpacity);
}

void Label::createShadowSpriteForSystemFont(const FontDefinition& fontDef)
{
    if (!fontDef._stroke._strokeEnabled && fontDef._fontFillColor == _shadowColor3B
        && (fontDef._fontAlpha == _shadowOpacity))
    {
        _shadowNode = Sprite::createWithTexture(_textSprite->getTexture());
    }
    else
    {
        FontDefinition shadowFontDefinition = fontDef;
        shadowFontDefinition._fontFillColor.r = _shadowColor3B.r;
        shadowFontDefinition._fontFillColor.g = _shadowColor3B.g;
        shadowFontDefinition._fontFillColor.b = _shadowColor3B.b;
        shadowFontDefinition._fontAlpha = _shadowOpacity;

        shadowFontDefinition._stroke._strokeColor = shadowFontDefinition._fontFillColor;
        shadowFontDefinition._stroke._strokeAlpha = shadowFontDefinition._fontAlpha;

        auto texture = new (std::nothrow) Urho3D::Texture2D(GetUrho3DContext());
        /*texture->i*/InitWithString(texture, _utf8Text.c_str(), shadowFontDefinition);
        _shadowNode = Sprite::createWithTexture(texture);
        //texture->release();
    }

    if (_shadowNode)
    {
        if (_blendFuncDirty)
        {
            _shadowNode->setBlendFunc(_blendFunc);
        }
        _shadowNode->setCameraMask(getCameraMask());
        _shadowNode->setGlobalZOrder(getGlobalZOrder());
        _shadowNode->setAnchorPoint(Vec2::ANCHOR_BOTTOM_LEFT);
        _shadowNode->setPosition(_shadowOffset.width, _shadowOffset.height);

        _shadowNode->retain();
        _shadowNode->updateDisplayedColor(_displayedColor);
        _shadowNode->updateDisplayedOpacity(_displayedOpacity);
    }
}

void Label::setCameraMask(unsigned short mask, bool applyChildren)
{
    Node::setCameraMask(mask, applyChildren);
    
    if (_textSprite)
    {
        _textSprite->setCameraMask(mask, applyChildren);
    }
    if (_shadowNode)
    {
        _shadowNode->setCameraMask(mask, applyChildren);
    }
}

void Label::setFontDefinition(const FontDefinition& textDefinition)
{
    _systemFont = textDefinition._fontName;
    _systemFontSize = textDefinition._fontSize;
    _hAlignment = textDefinition._alignment;
    _vAlignment = textDefinition._vertAlignment;
    setDimensions(textDefinition._dimensions.width, textDefinition._dimensions.height);
    Color4B textColor = Color4B(textDefinition._fontFillColor);
    textColor.a = textDefinition._fontAlpha;
    setTextColor(textColor);
    
#if (CC_TARGET_PLATFORM != CC_PLATFORM_ANDROID) && (CC_TARGET_PLATFORM != CC_PLATFORM_IOS)
    if (textDefinition._stroke._strokeEnabled)
    {
        CCLOGERROR(""Stroke Currently only supported on iOS and Android!"");
    }
    _outlineSize = 0.f;
#else
    if (textDefinition._stroke._strokeEnabled && textDefinition._stroke._strokeSize > 0.f)
    {
        Color4B outlineColor = Color4B(textDefinition._stroke._strokeColor);
        outlineColor.a = textDefinition._stroke._strokeAlpha;
        enableOutline(outlineColor, textDefinition._stroke._strokeSize);
    }
#endif

    if (textDefinition._shadow._shadowEnabled)
    {
        enableShadow(Color4B(0, 0, 0, 255 * textDefinition._shadow._shadowOpacity),
            textDefinition._shadow._shadowOffset, textDefinition._shadow._shadowBlur);
    }
}

void Label::updateContent()
{
    if (_systemFontDirty)
    {
        if (_fontAtlas)
        {
            _batchNodes.clear();
            CC_SAFE_RELEASE_NULL(_reusedLetter);
            FontAtlasCache::releaseFontAtlas(_fontAtlas);
            _fontAtlas = nullptr;
        }

        _systemFontDirty = false;
    }

    CC_SAFE_RELEASE_NULL(_textSprite);
    CC_SAFE_RELEASE_NULL(_shadowNode);
    bool updateFinished = true;

    if (_fontAtlas)
    {
        std::u32string utf32String;
        if (StringUtils::UTF8ToUTF32(_utf8Text, utf32String))
        {
            _utf32Text = utf32String;
        }

        computeHorizontalKernings(_utf32Text);
        updateFinished = alignText();
    }
    else
    {
        auto fontDef = _getFontDefinition();
        createSpriteForSystemFont(fontDef);
        if (_shadowEnabled)
        {
            createShadowSpriteForSystemFont(fontDef);
        }
    }

    if (_underlineNode)
    {
        _underlineNode->clear();

        if (_numberOfLines)
        {
            // This is the logic for TTF fonts
            const float charheight = (_textDesiredHeight / _numberOfLines);
            _underlineNode->setLineWidth(charheight/6);

            // atlas font
            for (int i=0; i<_numberOfLines; ++i)
            {
                float offsety = 0;
                if (_strikethroughEnabled)
                    offsety += charheight / 2;
                // FIXME: Might not work with different vertical alignments
                float y = (_numberOfLines - i - 1) * charheight + offsety;

                // Github issue #15214. Uses _displayedColor instead of _textColor for the underline.
                // This is to have the same behavior of SystemFonts.
                _underlineNode->drawLine(Vec2(_linesOffsetX[i],y), Vec2(_linesWidth[i] + _linesOffsetX[i],y), Color4F(_displayedColor));
            }
        }
        else if (_textSprite)
        {
            // ...and is the logic for System fonts
            float y = 0;
            const auto spriteSize = _textSprite->getContentSize();
            _underlineNode->setLineWidth(spriteSize.height/6);

            if (_strikethroughEnabled)
                // FIXME: system fonts don't report the height of the font correctly. only the size of the texture, which is POT
                y += spriteSize.height / 2;
            // FIXME: Might not work with different vertical alignments
            _underlineNode->drawLine(Vec2(0,y), Vec2(spriteSize.width,y), Color4F(_textSprite->getDisplayedColor()));
        }
    }

    if(updateFinished){
        _contentDirty = false;
    }

#if CC_LABEL_DEBUG_DRAW
    _debugDrawNode->clear();
    Vec2 vertices[4] =
    {
        Vec2::ZERO,
        Vec2(_contentSize.width, 0),
        Vec2(_contentSize.width, _contentSize.height),
        Vec2(0, _contentSize.height)
    };
    _debugDrawNode->drawPoly(vertices, 4, true, Color4F::WHITE);
#endif
}

void Label::setBMFontSize(float fontSize)
{
    this->setBMFontSizeInternal(fontSize);
    _originalFontSize = fontSize;
}

float Label::getBMFontSize()const
{
    return _bmFontSize;
}

void Label::onDrawShadow(GLProgramState* glProgram, const Color4F& shadowColor)
{
    auto graphics = GetUrho3DContext()->GetSubsystem<Urho3D::Graphics>();
    if (_currentLabelType == LabelType::TTF)
    {
        if (_currLabelEffect == LabelEffect::OUTLINE)
        {
            graphics->SetShaderParameter(_uniformEffectType, 2.0f);
            graphics->SetShaderParameter(_uniformEffectColor, Urho3D::Color{ shadowColor.r, shadowColor.g, shadowColor.b, shadowColor.a });
        }
        else
        {
            graphics->SetShaderParameter(_uniformTextColor, Urho3D::Color{ shadowColor.r, shadowColor.g, shadowColor.b, shadowColor.a });
            if (_currLabelEffect == LabelEffect::GLOW)
            {
                graphics->SetShaderParameter(_uniformEffectColor, Urho3D::Color{ shadowColor.r, shadowColor.g, shadowColor.b, shadowColor.a });
            }
        }

        glProgram->setUniformsForBuiltins(_shadowTransform);
        for (auto&& it : _letters)
        {
            it.second->updateTransform();
        }
        for (auto&& batchNode : _batchNodes)
        {
            batchNode->getTextureAtlas()->drawQuads();
        }
    }
    else
    {
        Color3B oldColor = _realColor;
        GLubyte oldOPacity = _displayedOpacity;
        _displayedOpacity = shadowColor.a * (oldOPacity / 255.0f) * 255;
        setColor(Color3B(shadowColor));

        glProgram->setUniformsForBuiltins(_shadowTransform);
        for (auto&& it : _letters)
        {
            it.second->updateTransform();
        }
        for (auto&& batchNode : _batchNodes)
        {
            batchNode->getTextureAtlas()->drawQuads();
        }

        _displayedOpacity = oldOPacity;
        setColor(oldColor);
    }
}

void Label::onDraw(const Mat4& transform, bool /*transformUpdated*/)
{
    auto graphics = GetUrho3DContext()->GetSubsystem<Urho3D::Graphics>();
    auto glprogram = getGLProgramState();/*getGLProgram()*/
    glprogram->apply();
    //GL::blendFunc(_blendFunc.src, _blendFunc.dst);
    graphics->SetBlendMode(BlendCocosToUrho3D(_blendFunc));
    if (_shadowEnabled)
    {
        if (_boldEnabled)
            onDrawShadow(glprogram, _textColorF);
        else
            onDrawShadow(glprogram, _shadowColor4F);
    }

    glprogram->setUniformsForBuiltins(transform);
    for (auto&& it : _letters)
    {
        it.second->updateTransform();
    }

    if (_currentLabelType == LabelType::TTF)
    {
        switch (_currLabelEffect) {
        case LabelEffect::OUTLINE:
            // draw outline of text
            graphics->SetShaderParameter(_uniformEffectType, 1.0f);
            graphics->SetShaderParameter(_uniformEffectColor, Urho3D::Color{ _effectColorF.r, _effectColorF.g, _effectColorF.b, _effectColorF.a });
            for (auto&& batchNode : _batchNodes)
            {
                batchNode->getTextureAtlas()->drawQuads();
            }

            // draw text without outline
            graphics->SetShaderParameter(_uniformEffectType, 0.0f);
            graphics->SetShaderParameter(_uniformTextColor, Urho3D::Color{ _textColorF.r, _textColorF.g, _textColorF.b, _textColorF.a });
            break;
        case LabelEffect::GLOW:
            graphics->SetShaderParameter(_uniformEffectColor, Urho3D::Color{ _effectColorF.r, _effectColorF.g, _effectColorF.b, _effectColorF.a });
        case LabelEffect::NORMAL:
            graphics->SetShaderParameter(_uniformTextColor, Urho3D::Color{ _textColorF.r, _textColorF.g, _textColorF.b, _textColorF.a });
            break;
        default:
            break;
        }
    }

    for (auto&& batchNode : _batchNodes)
    {
        batchNode->getTextureAtlas()->drawQuads();
    }
}

void Label::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
    if (_batchNodes.empty() || _lengthOfString <= 0)
    {
        return;
    }
    // Don't do calculate the culling if the transform was not updated
    bool transformUpdated = flags & FLAGS_TRANSFORM_DIRTY;
#if CC_USE_CULLING
    auto visitingCamera = Camera::getVisitingCamera();
    auto defaultCamera = Camera::getDefaultCamera();
    if (visitingCamera == defaultCamera) {
        _insideBounds = (transformUpdated || visitingCamera->isViewProjectionUpdated()) ? renderer->checkVisibility(transform, _contentSize) : _insideBounds;
    }
    else
    {
        _insideBounds = renderer->checkVisibility(transform, _contentSize);
    }

    if (_insideBounds)
#endif
    {
        if (!_shadowEnabled && (_currentLabelType == LabelType::BMFONT || _currentLabelType == LabelType::CHARMAP))
        {
            for (auto&& it : _letters)
            {
                it.second->updateTransform();
            }
            // ETC1 ALPHA supports for BMFONT & CHARMAP
            auto textureAtlas = _batchNodes.at(0)->getTextureAtlas();
            auto texture = textureAtlas->getTexture();
            _quadCommand.init(_globalZOrder, texture, getGLProgramState(), 
                _blendFunc, textureAtlas->getQuads(), textureAtlas->getTotalQuads(), transform, flags);
            renderer->addCommand(&_quadCommand);
        }
        else
        {
            _customCommand.init(_globalZOrder, transform, flags);
            _customCommand.func = CC_CALLBACK_0(Label::onDraw, this, transform, transformUpdated);

            renderer->addCommand(&_customCommand);
        }
    }
}

void Label::visit(Renderer *renderer, const Mat4 &parentTransform, uint32_t parentFlags)
{
    if (! _visible || (_utf8Text.empty() && _children.empty()) )
    {
        return;
    }
    
    if (_systemFontDirty || _contentDirty)
    {
        updateContent();
    }
    
    uint32_t flags = processParentFlags(parentTransform, parentFlags);

    if (!_utf8Text.empty() && _shadowEnabled && (_shadowDirty || (flags & FLAGS_DIRTY_MASK)))
    {
        _position.x += _shadowOffset.width;
        _position.y += _shadowOffset.height;
        _transformDirty = _inverseDirty = true;

        _shadowTransform = transform(parentTransform);

        _position.x -= _shadowOffset.width;
        _position.y -= _shadowOffset.height;
        _transformDirty = _inverseDirty = true;

        _shadowDirty = false;
    }

    bool visibleByCamera = isVisitableByVisitingCamera();
    if (_children.empty() && !_textSprite && !visibleByCamera)
    {
        return;
    }

    // IMPORTANT:
    // To ease the migration to v3.0, we still support the Mat4 stack,
    // but it is deprecated and your code should not rely on it
    _director->pushMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);
    _director->loadMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW, _modelViewTransform);
    
    if (!_children.empty())
    {
        sortAllChildren();

        int i = 0;
        // draw children zOrder < 0
        for (auto size = _children.size(); i < size; ++i)
        {
            auto node = _children.at(i);

            if (node && node->getLocalZOrder() < 0)
                node->visit(renderer, _modelViewTransform, flags);
            else
                break;
        }
        
        this->drawSelf(visibleByCamera, renderer, flags);

        for (auto it = _children.cbegin() + i, itCend = _children.cend(); it != itCend; ++it)
        {
            (*it)->visit(renderer, _modelViewTransform, flags);
        }
            
    }
    else
    {
        this->drawSelf(visibleByCamera, renderer, flags);
    }

    _director->popMatrix(MATRIX_STACK_TYPE::MATRIX_STACK_MODELVIEW);
}

void Label::drawSelf(bool visibleByCamera, Renderer* renderer, uint32_t flags)
{
    if (_textSprite)
    {
        if (_shadowNode)
        {
            _shadowNode->visit(renderer, _modelViewTransform, flags);
        }
        _textSprite->visit(renderer, _modelViewTransform, flags);
    }
    else if (visibleByCamera && !_utf8Text.empty())
    {
        draw(renderer, _modelViewTransform, flags);
    }
}

void Label::setSystemFontName(const std::string& systemFont)
{
    if (systemFont != _systemFont)
    {
        _systemFont = systemFont;
        _currentLabelType = LabelType::STRING_TEXTURE;
        _systemFontDirty = true;
    }
}

void Label::setSystemFontSize(float fontSize)
{
    if (_systemFontSize != fontSize)
    {
        _systemFontSize = fontSize;
        _originalFontSize = fontSize;
        _currentLabelType = LabelType::STRING_TEXTURE;
        _systemFontDirty = true;
    }
}

///// PROTOCOL STUFF
Sprite* Label::getLetter(int letterIndex)
{
    Sprite* letter = nullptr;
    do
    {
        if (_systemFontDirty || _currentLabelType == LabelType::STRING_TEXTURE)
        {
            break;
        }

        auto contentDirty = _contentDirty;
        if (contentDirty)
        {
            updateContent();
        }

        if (_textSprite == nullptr && letterIndex < _lengthOfString)
        {
            const auto &letterInfo = _lettersInfo[letterIndex];
            if (!letterInfo.valid || letterInfo.atlasIndex<0)
            {
                break;
            }

            if (_letters.find(letterIndex) != _letters.end())
            {
                letter = _letters[letterIndex];
            }

            if (letter == nullptr)
            {
                auto& letterDef = _fontAtlas->_letterDefinitions[letterInfo.utf32Char];
                auto textureID = letterDef.textureID;
                Rect uvRect;
                uvRect.size.height = letterDef.height;
                uvRect.size.width = letterDef.width;
                uvRect.origin.x = letterDef.U;
                uvRect.origin.y = letterDef.V;

                if (letterDef.width <= 0.f || letterDef.height <= 0.f)
                {
                    letter = LabelLetter::create();
                }
                else
                {
                    this->updateBMFontScale();
                    letter = LabelLetter::createWithTexture(_fontAtlas->getTexture(textureID), uvRect);
                    letter->setTextureAtlas(_batchNodes.at(textureID)->getTextureAtlas());
                    letter->setAtlasIndex(letterInfo.atlasIndex);
                    auto px = letterInfo.positionX + _bmfontScale * uvRect.size.width / 2 + _linesOffsetX[letterInfo.lineIndex];
                    auto py = letterInfo.positionY - _bmfontScale * uvRect.size.height / 2 + _letterOffsetY;
                    letter->setPosition(px,py);
                    letter->setOpacity(_realOpacity);
                    this->updateLetterSpriteScale(letter);
                }
                
                addChild(letter);
                _letters[letterIndex] = letter;
            }
        }
    } while (false);

    return letter;
}

void Label::setLineHeight(float height)
{
    CCASSERT(_currentLabelType != LabelType::STRING_TEXTURE, ""Not supported system font!"");

    if (_lineHeight != height)
    {
        _lineHeight = height;
        _contentDirty = true;
    }
}

float Label::getLineHeight() const
{
    CCASSERT(_currentLabelType != LabelType::STRING_TEXTURE, ""Not supported system font!"");
    return _textSprite ? 0.0f : _lineHeight * _bmfontScale;
}

void Label::setLineSpacing(float height)
{
    if (_lineSpacing != height)
    {
        _lineSpacing = height;
        _contentDirty = true;
    }
}

float Label::getLineSpacing() const
{
    return _lineSpacing;
}

void Label::setAdditionalKerning(float space)
{

    if (_currentLabelType != LabelType::STRING_TEXTURE)
    {
        if (_additionalKerning != space)
        {
            _additionalKerning = space;
            _contentDirty = true;
        }
    }
    else
        CCLOG(""Label::setAdditionalKerning not supported on LabelType::STRING_TEXTURE"");
}

float Label::getAdditionalKerning() const
{
    CCASSERT(_currentLabelType != LabelType::STRING_TEXTURE, ""Not supported system font!"");

    return _additionalKerning;
}

void Label::computeStringNumLines()
{
    int quantityOfLines = 1;

    if (_utf32Text.empty())
    {
        _numberOfLines = 0;
        return;
    }

    // count number of lines
    size_t stringLen = _utf32Text.length();
    for (size_t i = 0; i < stringLen - 1; ++i)
    {
        if (_utf32Text[i] == StringUtils::UnicodeCharacters::NewLine)
        {
            quantityOfLines++;
        }
    }

    _numberOfLines = quantityOfLines;
}

int Label::getStringNumLines()
{
    if (_contentDirty)
    {
        updateContent();
    }

    if (_currentLabelType == LabelType::STRING_TEXTURE)
    {
        computeStringNumLines();
    }

    return _numberOfLines;
}

int Label::getStringLength()
{
    _lengthOfString = static_cast<int>(_utf32Text.length());
    return _lengthOfString;
}

// RGBA protocol
void Label::setOpacityModifyRGB(bool isOpacityModifyRGB)
{
    if (isOpacityModifyRGB != _isOpacityModifyRGB)
    {
        _isOpacityModifyRGB = isOpacityModifyRGB;
        updateColor();
    }
}

void Label::updateDisplayedColor(const Color3B& parentColor)
{
    Node::updateDisplayedColor(parentColor);

    if (_textSprite)
    {
        _textSprite->updateDisplayedColor(_displayedColor);
    }

    if (_shadowNode)
    {
        _shadowNode->updateDisplayedColor(_displayedColor);
    }

    if (_underlineNode)
    {
        // FIXME: _underlineNode is not a sprite/label. It is a DrawNode
        // and updating its color doesn't work. it must be re-drawn,
        // which makes it super expensive to change update it frequently
        // Correct solution is to update the DrawNode directly since we know it is
        // a line. Returning a pointer to the line is an option
        _contentDirty = true;
    }

    for (auto&& it : _letters)
    {
        it.second->updateDisplayedColor(_displayedColor);
    }
}

void Label::updateDisplayedOpacity(GLubyte parentOpacity)
{
    Node::updateDisplayedOpacity(parentOpacity);

    if (_textSprite)
    {
        _textSprite->updateDisplayedOpacity(_displayedOpacity);
        if (_shadowNode)
        {
            _shadowNode->updateDisplayedOpacity(_displayedOpacity);
        }
    }

    for (auto&& it : _letters)
    {
        it.second->updateDisplayedOpacity(_displayedOpacity);
    }
}

// FIXME: it is not clear what is the difference between setTextColor() and setColor()
// if setTextColor() only changes the text and nothing but the text (no glow, no outline, not underline)
// that's fine but it should be documented
void Label::setTextColor(const Color4B &color)
{
    CCASSERT(_currentLabelType == LabelType::TTF || _currentLabelType == LabelType::STRING_TEXTURE, ""Only supported system font and ttf!"");

    if (_currentLabelType == LabelType::STRING_TEXTURE && _textColor != color)
    {
        _contentDirty = true;
    }

    _textColor = color;
    _textColorF.r = _textColor.r / 255.0f;
    _textColorF.g = _textColor.g / 255.0f;
    _textColorF.b = _textColor.b / 255.0f;
    _textColorF.a = _textColor.a / 255.0f;
}

void Label::updateColor()
{
    if (_batchNodes.empty())
    {
        return;
    }

    Color4B color4( _displayedColor.r, _displayedColor.g, _displayedColor.b, _displayedOpacity );

    // special opacity for premultiplied textures
    if (_isOpacityModifyRGB)
    {
        color4.r *= _displayedOpacity/255.0f;
        color4.g *= _displayedOpacity/255.0f;
        color4.b *= _displayedOpacity/255.0f;
    }

    cocos2d::TextureAtlas* textureAtlas;
    V3F_C4B_T2F_Quad *quads;
    for (auto&& batchNode:_batchNodes)
    {
        textureAtlas = batchNode->getTextureAtlas();
        quads = textureAtlas->getQuads();
        auto count = textureAtlas->getTotalQuads();

        for (int index = 0; index < count; ++index)
        {
            quads[index].bl.colors = color4;
            quads[index].br.colors = color4;
            quads[index].tl.colors = color4;
            quads[index].tr.colors = color4;
            textureAtlas->updateQuad(&quads[index], index);
        }
    }
}

std::string Label::getDescription() const
{
    char tmp[50];
    sprintf(tmp, ""<Label | Tag = %d, Label = >"", _tag);
    std::string ret = tmp;
    ret += _utf8Text;

    return ret;
}

const Size& Label::getContentSize() const
{
    if (_systemFontDirty || _contentDirty)
    {
        const_cast<Label*>(this)->updateContent();
    }
    return _contentSize;
}

Rect Label::getBoundingBox() const
{
    const_cast<Label*>(this)->getContentSize();

    return Node::getBoundingBox();
}

void Label::setBlendFunc(const BlendFunc &blendFunc)
{
    _blendFunc = blendFunc;
    _blendFuncDirty = true;
    if (_textSprite)
    {
        _textSprite->setBlendFunc(blendFunc);
        if (_shadowNode)
        {
            _shadowNode->setBlendFunc(blendFunc);
        }
    }
}

void Label::removeAllChildrenWithCleanup(bool cleanup)
{
    Node::removeAllChildrenWithCleanup(cleanup);
    _letters.clear();
}

void Label::removeChild(Node* child, bool cleanup /* = true */)
{
    Node::removeChild(child, cleanup);
    for (auto&& it : _letters)
    {
        if (it.second == child)
        {
            _letters.erase(it.first);
            break;
        }
    }
}

FontDefinition Label::_getFontDefinition() const
{
    FontDefinition systemFontDef;

    std::string fontName = _systemFont;
    if (_fontAtlas && !_fontAtlas->getFontName().empty()) fontName = _fontAtlas->getFontName();

    systemFontDef._fontName = fontName;
    systemFontDef._fontSize = _systemFontSize;
    systemFontDef._alignment = _hAlignment;
    systemFontDef._vertAlignment = _vAlignment;
    systemFontDef._lineSpacing = _lineSpacing;
    systemFontDef._dimensions.width = _labelWidth;
    systemFontDef._dimensions.height = _labelHeight;
    systemFontDef._fontFillColor.r = _textColor.r;
    systemFontDef._fontFillColor.g = _textColor.g;
    systemFontDef._fontFillColor.b = _textColor.b;
    systemFontDef._fontAlpha = _textColor.a;
    systemFontDef._shadow._shadowEnabled = false;
    systemFontDef._enableWrap = _enableWrap;
    systemFontDef._overflow = (int)_overflow;

    if (_currLabelEffect == LabelEffect::OUTLINE && _outlineSize > 0.f)
    {
        systemFontDef._stroke._strokeEnabled = true;
        systemFontDef._stroke._strokeSize = _outlineSize;
        systemFontDef._stroke._strokeColor.r = _effectColorF.r * 255;
        systemFontDef._stroke._strokeColor.g = _effectColorF.g * 255;
        systemFontDef._stroke._strokeColor.b = _effectColorF.b * 255;
        systemFontDef._stroke._strokeAlpha = _effectColorF.a * 255;
    }
    else
    {
        systemFontDef._stroke._strokeEnabled = false;
    }

#if (CC_TARGET_PLATFORM != CC_PLATFORM_ANDROID) && (CC_TARGET_PLATFORM != CC_PLATFORM_IOS)
    if (systemFontDef._stroke._strokeEnabled)
    {
        CCLOGERROR(""Stroke Currently only supported on iOS and Android!"");
    }
    systemFontDef._stroke._strokeEnabled = false;
#endif

    return systemFontDef;
}

void Label::setGlobalZOrder(float globalZOrder)
{
    Node::setGlobalZOrder(globalZOrder);
    if (_textSprite)
    {
        _textSprite->setGlobalZOrder(globalZOrder);
        if (_shadowNode)
        {
            _shadowNode->setGlobalZOrder(globalZOrder);
        }
    }
}

float Label::getRenderingFontSize()const
{
    float fontSize;
    if (_currentLabelType == LabelType::BMFONT) {
        fontSize = _bmFontSize;
    }else if(_currentLabelType == LabelType::TTF){
        fontSize = this->getTTFConfig().fontSize;
    }else if(_currentLabelType == LabelType::STRING_TEXTURE){
        fontSize = _systemFontSize;
    }else{ //FIXME: find a way to calculate char map font size
        fontSize = this->getLineHeight();
    }
    return fontSize;
}

void Label::enableWrap(bool enable)
{
    if(enable == _enableWrap || _overflow == Overflow::RESIZE_HEIGHT){
        return;
    }

    this->_enableWrap = enable;
   
    this->rescaleWithOriginalFontSize();
    
    _contentDirty = true;
}

bool Label::isWrapEnabled()const
{
    return this->_enableWrap;
}

void Label::setOverflow(Overflow overflow)
{
    if(_overflow == overflow){
        return;
    }
    
    if (_currentLabelType == LabelType::CHARMAP) {
        if (overflow == Overflow::SHRINK) {
            return;
        }
    }

    if(overflow == Overflow::RESIZE_HEIGHT){
        this->setDimensions(_labelDimensions.width,0);
        this->enableWrap(true);
    }
    _overflow = overflow;
    
    this->rescaleWithOriginalFontSize();
    
    _contentDirty = true;
}

void Label::rescaleWithOriginalFontSize()
{
    auto renderingFontSize = this->getRenderingFontSize();
    if (_originalFontSize - renderingFontSize >= 1) {
        this->scaleFontSizeDown(_originalFontSize);
    }
}

Label::Overflow Label::getOverflow()const
{
    return _overflow;
}

void Label::updateLetterSpriteScale(Sprite* sprite)
{
    if (_currentLabelType == LabelType::BMFONT && _bmFontSize > 0)
    {
        sprite->setScale(_bmfontScale);
    }
    else
    {
        if (std::abs(_bmFontSize) < FLT_EPSILON)
        {
            sprite->setScale(0);
        }
        else
        {
            sprite->setScale(1.0);
        }
    }
}

NS_CC_END
",16161,True,3061.2991134468753,median
"// (c) Copyright 1995-2022 Xilinx, Inc. All rights reserved.
// 
// This file contains confidential and proprietary information
// of Xilinx, Inc. and is protected under U.S. and
// international copyright and other intellectual property
// laws.
// 
// DISCLAIMER
// This disclaimer is not a license and does not grant any
// rights to the materials distributed herewith. Except as
// otherwise provided in a valid license issued to you by
// Xilinx, and to the maximum extent permitted by applicable
// law: (1) THESE MATERIALS ARE MADE AVAILABLE ""AS IS"" AND
// WITH ALL FAULTS, AND XILINX HEREBY DISCLAIMS ALL WARRANTIES
// AND CONDITIONS, EXPRESS, IMPLIED, OR STATUTORY, INCLUDING
// BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, NON-
// INFRINGEMENT, OR FITNESS FOR ANY PARTICULAR PURPOSE; and
// (2) Xilinx shall not be liable (whether in contract or tort,
// including negligence, or under any other theory of
// liability) for any loss or damage of any kind or nature
// related to, arising under or in connection with these
// materials, including for any direct, or any indirect,
// special, incidental, or consequential loss or damage
// (including loss of data, profits, goodwill, or any type of
// loss or damage suffered as a result of any action brought
// by a third party) even if such damage or loss was
// reasonably foreseeable or Xilinx had been advised of the
// possibility of the same.
// 
// CRITICAL APPLICATIONS
// Xilinx products are not designed or intended to be fail-
// safe, or for use in any application requiring fail-safe
// performance, such as life-support or safety devices or
// systems, Class III medical devices, nuclear facilities,
// applications related to the deployment of airbags, or any
// other applications that could lead to death, personal
// injury, or severe property or environmental damage
// (individually and collectively, ""Critical
// Applications""). Customer assumes the sole risk and
// liability of any use of Xilinx products in Critical
// Applications, subject only to applicable laws and
// regulations governing limitations on product liability.
// 
// THIS COPYRIGHT NOTICE AND DISCLAIMER MUST BE RETAINED AS
// PART OF THIS FILE AT ALL TIMES.
// 
// DO NOT MODIFY THIS FILE.


#include ""video_cp_auto_cc_3_sc.h""

#include ""video_cp_auto_cc_3.h""

#include ""axi_clock_converter.h""

#include <map>
#include <string>





#ifdef XILINX_SIMULATOR
video_cp_auto_cc_3::video_cp_auto_cc_3(const sc_core::sc_module_name& nm) : video_cp_auto_cc_3_sc(nm), s_axi_aclk(""s_axi_aclk""), s_axi_aresetn(""s_axi_aresetn""), s_axi_awaddr(""s_axi_awaddr""), s_axi_awprot(""s_axi_awprot""), s_axi_awvalid(""s_axi_awvalid""), s_axi_awready(""s_axi_awready""), s_axi_wdata(""s_axi_wdata""), s_axi_wstrb(""s_axi_wstrb""), s_axi_wvalid(""s_axi_wvalid""), s_axi_wready(""s_axi_wready""), s_axi_bresp(""s_axi_bresp""), s_axi_bvalid(""s_axi_bvalid""), s_axi_bready(""s_axi_bready""), s_axi_araddr(""s_axi_araddr""), s_axi_arprot(""s_axi_arprot""), s_axi_arvalid(""s_axi_arvalid""), s_axi_arready(""s_axi_arready""), s_axi_rdata(""s_axi_rdata""), s_axi_rresp(""s_axi_rresp""), s_axi_rvalid(""s_axi_rvalid""), s_axi_rready(""s_axi_rready""), m_axi_aclk(""m_axi_aclk""), m_axi_aresetn(""m_axi_aresetn""), m_axi_awaddr(""m_axi_awaddr""), m_axi_awprot(""m_axi_awprot""), m_axi_awvalid(""m_axi_awvalid""), m_axi_awready(""m_axi_awready""), m_axi_wdata(""m_axi_wdata""), m_axi_wstrb(""m_axi_wstrb""), m_axi_wvalid(""m_axi_wvalid""), m_axi_wready(""m_axi_wready""), m_axi_bresp(""m_axi_bresp""), m_axi_bvalid(""m_axi_bvalid""), m_axi_bready(""m_axi_bready""), m_axi_araddr(""m_axi_araddr""), m_axi_arprot(""m_axi_arprot""), m_axi_arvalid(""m_axi_arvalid""), m_axi_arready(""m_axi_arready""), m_axi_rdata(""m_axi_rdata""), m_axi_rresp(""m_axi_rresp""), m_axi_rvalid(""m_axi_rvalid""), m_axi_rready(""m_axi_rready"")
{

  // initialize pins
  mp_impl->s_axi_aclk(s_axi_aclk);
  mp_impl->s_axi_aresetn(s_axi_aresetn);
  mp_impl->m_axi_aclk(m_axi_aclk);
  mp_impl->m_axi_aresetn(m_axi_aresetn);

  // initialize transactors
  mp_S_AXI_transactor = NULL;
  mp_M_AXI_transactor = NULL;

  // initialize socket stubs

}

void video_cp_auto_cc_3::before_end_of_elaboration()
{
  // configure 'S_AXI' transactor

  if (xsc::utils::xsc_sim_manager::getInstanceParameterInt(""video_cp_auto_cc_3"", ""S_AXI_TLM_MODE"") != 1)
  {
    // Instantiate Socket Stubs

  // 'S_AXI' transactor parameters
    xsc::common_cpp::properties S_AXI_transactor_param_props;
    S_AXI_transactor_param_props.addLong(""DATA_WIDTH"", ""32"");
    S_AXI_transactor_param_props.addLong(""FREQ_HZ"", ""100000000"");
    S_AXI_transactor_param_props.addLong(""ID_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""ADDR_WIDTH"", ""5"");
    S_AXI_transactor_param_props.addLong(""AWUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""ARUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""WUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""RUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""BUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_BURST"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_LOCK"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_PROT"", ""1"");
    S_AXI_transactor_param_props.addLong(""HAS_CACHE"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_QOS"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_REGION"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_WSTRB"", ""1"");
    S_AXI_transactor_param_props.addLong(""HAS_BRESP"", ""1"");
    S_AXI_transactor_param_props.addLong(""HAS_RRESP"", ""1"");
    S_AXI_transactor_param_props.addLong(""SUPPORTS_NARROW_BURST"", ""0"");
    S_AXI_transactor_param_props.addLong(""NUM_READ_OUTSTANDING"", ""8"");
    S_AXI_transactor_param_props.addLong(""NUM_WRITE_OUTSTANDING"", ""8"");
    S_AXI_transactor_param_props.addLong(""MAX_BURST_LENGTH"", ""1"");
    S_AXI_transactor_param_props.addLong(""NUM_READ_THREADS"", ""1"");
    S_AXI_transactor_param_props.addLong(""NUM_WRITE_THREADS"", ""1"");
    S_AXI_transactor_param_props.addLong(""RUSER_BITS_PER_BYTE"", ""0"");
    S_AXI_transactor_param_props.addLong(""WUSER_BITS_PER_BYTE"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_SIZE"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_RESET"", ""0"");
    S_AXI_transactor_param_props.addFloat(""PHASE"", ""0.000"");
    S_AXI_transactor_param_props.addString(""PROTOCOL"", ""AXI4LITE"");
    S_AXI_transactor_param_props.addString(""READ_WRITE_MODE"", ""READ_WRITE"");
    S_AXI_transactor_param_props.addString(""CLK_DOMAIN"", ""video_cp_ps7_0_0_FCLK_CLK0"");

    mp_S_AXI_transactor = new xtlm::xaximm_pin2xtlm_t<32,5,1,1,1,1,1,1>(""S_AXI_transactor"", S_AXI_transactor_param_props);

    // S_AXI' transactor ports

    mp_S_AXI_transactor->AWADDR(s_axi_awaddr);
    mp_S_AXI_transactor->AWPROT(s_axi_awprot);
    mp_S_AXI_transactor->AWVALID(s_axi_awvalid);
    mp_S_AXI_transactor->AWREADY(s_axi_awready);
    mp_S_AXI_transactor->WDATA(s_axi_wdata);
    mp_S_AXI_transactor->WSTRB(s_axi_wstrb);
    mp_S_AXI_transactor->WVALID(s_axi_wvalid);
    mp_S_AXI_transactor->WREADY(s_axi_wready);
    mp_S_AXI_transactor->BRESP(s_axi_bresp);
    mp_S_AXI_transactor->BVALID(s_axi_bvalid);
    mp_S_AXI_transactor->BREADY(s_axi_bready);
    mp_S_AXI_transactor->ARADDR(s_axi_araddr);
    mp_S_AXI_transactor->ARPROT(s_axi_arprot);
    mp_S_AXI_transactor->ARVALID(s_axi_arvalid);
    mp_S_AXI_transactor->ARREADY(s_axi_arready);
    mp_S_AXI_transactor->RDATA(s_axi_rdata);
    mp_S_AXI_transactor->RRESP(s_axi_rresp);
    mp_S_AXI_transactor->RVALID(s_axi_rvalid);
    mp_S_AXI_transactor->RREADY(s_axi_rready);
    mp_S_AXI_transactor->CLK(s_axi_aclk);
    m_S_AXI_transactor_rst_signal.write(1);
    mp_S_AXI_transactor->RST(m_S_AXI_transactor_rst_signal);

    // S_AXI' transactor sockets

    mp_impl->S_TARGET_rd_socket->bind(*(mp_S_AXI_transactor->rd_socket));
    mp_impl->S_TARGET_wr_socket->bind(*(mp_S_AXI_transactor->wr_socket));
  }
  else
  {
  }

  // configure 'M_AXI' transactor

  if (xsc::utils::xsc_sim_manager::getInstanceParameterInt(""video_cp_auto_cc_3"", ""M_AXI_TLM_MODE"") != 1)
  {
    // Instantiate Socket Stubs

  // 'M_AXI' transactor parameters
    xsc::common_cpp::properties M_AXI_transactor_param_props;
    M_AXI_transactor_param_props.addLong(""DATA_WIDTH"", ""32"");
    M_AXI_transactor_param_props.addLong(""FREQ_HZ"", ""142857132"");
    M_AXI_transactor_param_props.addLong(""ID_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""ADDR_WIDTH"", ""5"");
    M_AXI_transactor_param_props.addLong(""AWUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""ARUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""WUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""RUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""BUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_BURST"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_LOCK"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_PROT"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_CACHE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_QOS"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_REGION"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_WSTRB"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_BRESP"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_RRESP"", ""1"");
    M_AXI_transactor_param_props.addLong(""SUPPORTS_NARROW_BURST"", ""0"");
    M_AXI_transactor_param_props.addLong(""NUM_READ_OUTSTANDING"", ""8"");
    M_AXI_transactor_param_props.addLong(""NUM_WRITE_OUTSTANDING"", ""8"");
    M_AXI_transactor_param_props.addLong(""MAX_BURST_LENGTH"", ""1"");
    M_AXI_transactor_param_props.addLong(""NUM_READ_THREADS"", ""1"");
    M_AXI_transactor_param_props.addLong(""NUM_WRITE_THREADS"", ""1"");
    M_AXI_transactor_param_props.addLong(""RUSER_BITS_PER_BYTE"", ""0"");
    M_AXI_transactor_param_props.addLong(""WUSER_BITS_PER_BYTE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_SIZE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_RESET"", ""0"");
    M_AXI_transactor_param_props.addFloat(""PHASE"", ""0.000"");
    M_AXI_transactor_param_props.addString(""PROTOCOL"", ""AXI4LITE"");
    M_AXI_transactor_param_props.addString(""READ_WRITE_MODE"", ""READ_WRITE"");
    M_AXI_transactor_param_props.addString(""CLK_DOMAIN"", ""video_cp_ps7_0_0_FCLK_CLK1"");

    mp_M_AXI_transactor = new xtlm::xaximm_xtlm2pin_t<32,5,1,1,1,1,1,1>(""M_AXI_transactor"", M_AXI_transactor_param_props);

    // M_AXI' transactor ports

    mp_M_AXI_transactor->AWADDR(m_axi_awaddr);
    mp_M_AXI_transactor->AWPROT(m_axi_awprot);
    mp_M_AXI_transactor->AWVALID(m_axi_awvalid);
    mp_M_AXI_transactor->AWREADY(m_axi_awready);
    mp_M_AXI_transactor->WDATA(m_axi_wdata);
    mp_M_AXI_transactor->WSTRB(m_axi_wstrb);
    mp_M_AXI_transactor->WVALID(m_axi_wvalid);
    mp_M_AXI_transactor->WREADY(m_axi_wready);
    mp_M_AXI_transactor->BRESP(m_axi_bresp);
    mp_M_AXI_transactor->BVALID(m_axi_bvalid);
    mp_M_AXI_transactor->BREADY(m_axi_bready);
    mp_M_AXI_transactor->ARADDR(m_axi_araddr);
    mp_M_AXI_transactor->ARPROT(m_axi_arprot);
    mp_M_AXI_transactor->ARVALID(m_axi_arvalid);
    mp_M_AXI_transactor->ARREADY(m_axi_arready);
    mp_M_AXI_transactor->RDATA(m_axi_rdata);
    mp_M_AXI_transactor->RRESP(m_axi_rresp);
    mp_M_AXI_transactor->RVALID(m_axi_rvalid);
    mp_M_AXI_transactor->RREADY(m_axi_rready);
    mp_M_AXI_transactor->CLK(m_axi_aclk);
    m_M_AXI_transactor_rst_signal.write(1);
    mp_M_AXI_transactor->RST(m_M_AXI_transactor_rst_signal);

    // M_AXI' transactor sockets

    mp_impl->M_INITIATOR_rd_socket->bind(*(mp_M_AXI_transactor->rd_socket));
    mp_impl->M_INITIATOR_wr_socket->bind(*(mp_M_AXI_transactor->wr_socket));
  }
  else
  {
  }

}

#endif // XILINX_SIMULATOR




#ifdef XM_SYSTEMC
video_cp_auto_cc_3::video_cp_auto_cc_3(const sc_core::sc_module_name& nm) : video_cp_auto_cc_3_sc(nm), s_axi_aclk(""s_axi_aclk""), s_axi_aresetn(""s_axi_aresetn""), s_axi_awaddr(""s_axi_awaddr""), s_axi_awprot(""s_axi_awprot""), s_axi_awvalid(""s_axi_awvalid""), s_axi_awready(""s_axi_awready""), s_axi_wdata(""s_axi_wdata""), s_axi_wstrb(""s_axi_wstrb""), s_axi_wvalid(""s_axi_wvalid""), s_axi_wready(""s_axi_wready""), s_axi_bresp(""s_axi_bresp""), s_axi_bvalid(""s_axi_bvalid""), s_axi_bready(""s_axi_bready""), s_axi_araddr(""s_axi_araddr""), s_axi_arprot(""s_axi_arprot""), s_axi_arvalid(""s_axi_arvalid""), s_axi_arready(""s_axi_arready""), s_axi_rdata(""s_axi_rdata""), s_axi_rresp(""s_axi_rresp""), s_axi_rvalid(""s_axi_rvalid""), s_axi_rready(""s_axi_rready""), m_axi_aclk(""m_axi_aclk""), m_axi_aresetn(""m_axi_aresetn""), m_axi_awaddr(""m_axi_awaddr""), m_axi_awprot(""m_axi_awprot""), m_axi_awvalid(""m_axi_awvalid""), m_axi_awready(""m_axi_awready""), m_axi_wdata(""m_axi_wdata""), m_axi_wstrb(""m_axi_wstrb""), m_axi_wvalid(""m_axi_wvalid""), m_axi_wready(""m_axi_wready""), m_axi_bresp(""m_axi_bresp""), m_axi_bvalid(""m_axi_bvalid""), m_axi_bready(""m_axi_bready""), m_axi_araddr(""m_axi_araddr""), m_axi_arprot(""m_axi_arprot""), m_axi_arvalid(""m_axi_arvalid""), m_axi_arready(""m_axi_arready""), m_axi_rdata(""m_axi_rdata""), m_axi_rresp(""m_axi_rresp""), m_axi_rvalid(""m_axi_rvalid""), m_axi_rready(""m_axi_rready"")
{

  // initialize pins
  mp_impl->s_axi_aclk(s_axi_aclk);
  mp_impl->s_axi_aresetn(s_axi_aresetn);
  mp_impl->m_axi_aclk(m_axi_aclk);
  mp_impl->m_axi_aresetn(m_axi_aresetn);

  // initialize transactors
  mp_S_AXI_transactor = NULL;
  mp_M_AXI_transactor = NULL;

  // initialize socket stubs

}

void video_cp_auto_cc_3::before_end_of_elaboration()
{
  // configure 'S_AXI' transactor

  if (xsc::utils::xsc_sim_manager::getInstanceParameterInt(""video_cp_auto_cc_3"", ""S_AXI_TLM_MODE"") != 1)
  {
    // Instantiate Socket Stubs

  // 'S_AXI' transactor parameters
    xsc::common_cpp::properties S_AXI_transactor_param_props;
    S_AXI_transactor_param_props.addLong(""DATA_WIDTH"", ""32"");
    S_AXI_transactor_param_props.addLong(""FREQ_HZ"", ""100000000"");
    S_AXI_transactor_param_props.addLong(""ID_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""ADDR_WIDTH"", ""5"");
    S_AXI_transactor_param_props.addLong(""AWUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""ARUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""WUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""RUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""BUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_BURST"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_LOCK"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_PROT"", ""1"");
    S_AXI_transactor_param_props.addLong(""HAS_CACHE"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_QOS"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_REGION"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_WSTRB"", ""1"");
    S_AXI_transactor_param_props.addLong(""HAS_BRESP"", ""1"");
    S_AXI_transactor_param_props.addLong(""HAS_RRESP"", ""1"");
    S_AXI_transactor_param_props.addLong(""SUPPORTS_NARROW_BURST"", ""0"");
    S_AXI_transactor_param_props.addLong(""NUM_READ_OUTSTANDING"", ""8"");
    S_AXI_transactor_param_props.addLong(""NUM_WRITE_OUTSTANDING"", ""8"");
    S_AXI_transactor_param_props.addLong(""MAX_BURST_LENGTH"", ""1"");
    S_AXI_transactor_param_props.addLong(""NUM_READ_THREADS"", ""1"");
    S_AXI_transactor_param_props.addLong(""NUM_WRITE_THREADS"", ""1"");
    S_AXI_transactor_param_props.addLong(""RUSER_BITS_PER_BYTE"", ""0"");
    S_AXI_transactor_param_props.addLong(""WUSER_BITS_PER_BYTE"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_SIZE"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_RESET"", ""0"");
    S_AXI_transactor_param_props.addFloat(""PHASE"", ""0.000"");
    S_AXI_transactor_param_props.addString(""PROTOCOL"", ""AXI4LITE"");
    S_AXI_transactor_param_props.addString(""READ_WRITE_MODE"", ""READ_WRITE"");
    S_AXI_transactor_param_props.addString(""CLK_DOMAIN"", ""video_cp_ps7_0_0_FCLK_CLK0"");

    mp_S_AXI_transactor = new xtlm::xaximm_pin2xtlm_t<32,5,1,1,1,1,1,1>(""S_AXI_transactor"", S_AXI_transactor_param_props);

    // S_AXI' transactor ports

    mp_S_AXI_transactor->AWADDR(s_axi_awaddr);
    mp_S_AXI_transactor->AWPROT(s_axi_awprot);
    mp_S_AXI_transactor->AWVALID(s_axi_awvalid);
    mp_S_AXI_transactor->AWREADY(s_axi_awready);
    mp_S_AXI_transactor->WDATA(s_axi_wdata);
    mp_S_AXI_transactor->WSTRB(s_axi_wstrb);
    mp_S_AXI_transactor->WVALID(s_axi_wvalid);
    mp_S_AXI_transactor->WREADY(s_axi_wready);
    mp_S_AXI_transactor->BRESP(s_axi_bresp);
    mp_S_AXI_transactor->BVALID(s_axi_bvalid);
    mp_S_AXI_transactor->BREADY(s_axi_bready);
    mp_S_AXI_transactor->ARADDR(s_axi_araddr);
    mp_S_AXI_transactor->ARPROT(s_axi_arprot);
    mp_S_AXI_transactor->ARVALID(s_axi_arvalid);
    mp_S_AXI_transactor->ARREADY(s_axi_arready);
    mp_S_AXI_transactor->RDATA(s_axi_rdata);
    mp_S_AXI_transactor->RRESP(s_axi_rresp);
    mp_S_AXI_transactor->RVALID(s_axi_rvalid);
    mp_S_AXI_transactor->RREADY(s_axi_rready);
    mp_S_AXI_transactor->CLK(s_axi_aclk);
    m_S_AXI_transactor_rst_signal.write(1);
    mp_S_AXI_transactor->RST(m_S_AXI_transactor_rst_signal);

    // S_AXI' transactor sockets

    mp_impl->S_TARGET_rd_socket->bind(*(mp_S_AXI_transactor->rd_socket));
    mp_impl->S_TARGET_wr_socket->bind(*(mp_S_AXI_transactor->wr_socket));
  }
  else
  {
  }

  // configure 'M_AXI' transactor

  if (xsc::utils::xsc_sim_manager::getInstanceParameterInt(""video_cp_auto_cc_3"", ""M_AXI_TLM_MODE"") != 1)
  {
    // Instantiate Socket Stubs

  // 'M_AXI' transactor parameters
    xsc::common_cpp::properties M_AXI_transactor_param_props;
    M_AXI_transactor_param_props.addLong(""DATA_WIDTH"", ""32"");
    M_AXI_transactor_param_props.addLong(""FREQ_HZ"", ""142857132"");
    M_AXI_transactor_param_props.addLong(""ID_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""ADDR_WIDTH"", ""5"");
    M_AXI_transactor_param_props.addLong(""AWUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""ARUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""WUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""RUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""BUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_BURST"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_LOCK"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_PROT"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_CACHE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_QOS"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_REGION"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_WSTRB"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_BRESP"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_RRESP"", ""1"");
    M_AXI_transactor_param_props.addLong(""SUPPORTS_NARROW_BURST"", ""0"");
    M_AXI_transactor_param_props.addLong(""NUM_READ_OUTSTANDING"", ""8"");
    M_AXI_transactor_param_props.addLong(""NUM_WRITE_OUTSTANDING"", ""8"");
    M_AXI_transactor_param_props.addLong(""MAX_BURST_LENGTH"", ""1"");
    M_AXI_transactor_param_props.addLong(""NUM_READ_THREADS"", ""1"");
    M_AXI_transactor_param_props.addLong(""NUM_WRITE_THREADS"", ""1"");
    M_AXI_transactor_param_props.addLong(""RUSER_BITS_PER_BYTE"", ""0"");
    M_AXI_transactor_param_props.addLong(""WUSER_BITS_PER_BYTE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_SIZE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_RESET"", ""0"");
    M_AXI_transactor_param_props.addFloat(""PHASE"", ""0.000"");
    M_AXI_transactor_param_props.addString(""PROTOCOL"", ""AXI4LITE"");
    M_AXI_transactor_param_props.addString(""READ_WRITE_MODE"", ""READ_WRITE"");
    M_AXI_transactor_param_props.addString(""CLK_DOMAIN"", ""video_cp_ps7_0_0_FCLK_CLK1"");

    mp_M_AXI_transactor = new xtlm::xaximm_xtlm2pin_t<32,5,1,1,1,1,1,1>(""M_AXI_transactor"", M_AXI_transactor_param_props);

    // M_AXI' transactor ports

    mp_M_AXI_transactor->AWADDR(m_axi_awaddr);
    mp_M_AXI_transactor->AWPROT(m_axi_awprot);
    mp_M_AXI_transactor->AWVALID(m_axi_awvalid);
    mp_M_AXI_transactor->AWREADY(m_axi_awready);
    mp_M_AXI_transactor->WDATA(m_axi_wdata);
    mp_M_AXI_transactor->WSTRB(m_axi_wstrb);
    mp_M_AXI_transactor->WVALID(m_axi_wvalid);
    mp_M_AXI_transactor->WREADY(m_axi_wready);
    mp_M_AXI_transactor->BRESP(m_axi_bresp);
    mp_M_AXI_transactor->BVALID(m_axi_bvalid);
    mp_M_AXI_transactor->BREADY(m_axi_bready);
    mp_M_AXI_transactor->ARADDR(m_axi_araddr);
    mp_M_AXI_transactor->ARPROT(m_axi_arprot);
    mp_M_AXI_transactor->ARVALID(m_axi_arvalid);
    mp_M_AXI_transactor->ARREADY(m_axi_arready);
    mp_M_AXI_transactor->RDATA(m_axi_rdata);
    mp_M_AXI_transactor->RRESP(m_axi_rresp);
    mp_M_AXI_transactor->RVALID(m_axi_rvalid);
    mp_M_AXI_transactor->RREADY(m_axi_rready);
    mp_M_AXI_transactor->CLK(m_axi_aclk);
    m_M_AXI_transactor_rst_signal.write(1);
    mp_M_AXI_transactor->RST(m_M_AXI_transactor_rst_signal);

    // M_AXI' transactor sockets

    mp_impl->M_INITIATOR_rd_socket->bind(*(mp_M_AXI_transactor->rd_socket));
    mp_impl->M_INITIATOR_wr_socket->bind(*(mp_M_AXI_transactor->wr_socket));
  }
  else
  {
  }

}

#endif // XM_SYSTEMC




#ifdef RIVIERA
video_cp_auto_cc_3::video_cp_auto_cc_3(const sc_core::sc_module_name& nm) : video_cp_auto_cc_3_sc(nm), s_axi_aclk(""s_axi_aclk""), s_axi_aresetn(""s_axi_aresetn""), s_axi_awaddr(""s_axi_awaddr""), s_axi_awprot(""s_axi_awprot""), s_axi_awvalid(""s_axi_awvalid""), s_axi_awready(""s_axi_awready""), s_axi_wdata(""s_axi_wdata""), s_axi_wstrb(""s_axi_wstrb""), s_axi_wvalid(""s_axi_wvalid""), s_axi_wready(""s_axi_wready""), s_axi_bresp(""s_axi_bresp""), s_axi_bvalid(""s_axi_bvalid""), s_axi_bready(""s_axi_bready""), s_axi_araddr(""s_axi_araddr""), s_axi_arprot(""s_axi_arprot""), s_axi_arvalid(""s_axi_arvalid""), s_axi_arready(""s_axi_arready""), s_axi_rdata(""s_axi_rdata""), s_axi_rresp(""s_axi_rresp""), s_axi_rvalid(""s_axi_rvalid""), s_axi_rready(""s_axi_rready""), m_axi_aclk(""m_axi_aclk""), m_axi_aresetn(""m_axi_aresetn""), m_axi_awaddr(""m_axi_awaddr""), m_axi_awprot(""m_axi_awprot""), m_axi_awvalid(""m_axi_awvalid""), m_axi_awready(""m_axi_awready""), m_axi_wdata(""m_axi_wdata""), m_axi_wstrb(""m_axi_wstrb""), m_axi_wvalid(""m_axi_wvalid""), m_axi_wready(""m_axi_wready""), m_axi_bresp(""m_axi_bresp""), m_axi_bvalid(""m_axi_bvalid""), m_axi_bready(""m_axi_bready""), m_axi_araddr(""m_axi_araddr""), m_axi_arprot(""m_axi_arprot""), m_axi_arvalid(""m_axi_arvalid""), m_axi_arready(""m_axi_arready""), m_axi_rdata(""m_axi_rdata""), m_axi_rresp(""m_axi_rresp""), m_axi_rvalid(""m_axi_rvalid""), m_axi_rready(""m_axi_rready"")
{

  // initialize pins
  mp_impl->s_axi_aclk(s_axi_aclk);
  mp_impl->s_axi_aresetn(s_axi_aresetn);
  mp_impl->m_axi_aclk(m_axi_aclk);
  mp_impl->m_axi_aresetn(m_axi_aresetn);

  // initialize transactors
  mp_S_AXI_transactor = NULL;
  mp_M_AXI_transactor = NULL;

  // initialize socket stubs

}

void video_cp_auto_cc_3::before_end_of_elaboration()
{
  // configure 'S_AXI' transactor

  if (xsc::utils::xsc_sim_manager::getInstanceParameterInt(""video_cp_auto_cc_3"", ""S_AXI_TLM_MODE"") != 1)
  {
    // Instantiate Socket Stubs

  // 'S_AXI' transactor parameters
    xsc::common_cpp::properties S_AXI_transactor_param_props;
    S_AXI_transactor_param_props.addLong(""DATA_WIDTH"", ""32"");
    S_AXI_transactor_param_props.addLong(""FREQ_HZ"", ""100000000"");
    S_AXI_transactor_param_props.addLong(""ID_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""ADDR_WIDTH"", ""5"");
    S_AXI_transactor_param_props.addLong(""AWUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""ARUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""WUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""RUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""BUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_BURST"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_LOCK"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_PROT"", ""1"");
    S_AXI_transactor_param_props.addLong(""HAS_CACHE"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_QOS"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_REGION"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_WSTRB"", ""1"");
    S_AXI_transactor_param_props.addLong(""HAS_BRESP"", ""1"");
    S_AXI_transactor_param_props.addLong(""HAS_RRESP"", ""1"");
    S_AXI_transactor_param_props.addLong(""SUPPORTS_NARROW_BURST"", ""0"");
    S_AXI_transactor_param_props.addLong(""NUM_READ_OUTSTANDING"", ""8"");
    S_AXI_transactor_param_props.addLong(""NUM_WRITE_OUTSTANDING"", ""8"");
    S_AXI_transactor_param_props.addLong(""MAX_BURST_LENGTH"", ""1"");
    S_AXI_transactor_param_props.addLong(""NUM_READ_THREADS"", ""1"");
    S_AXI_transactor_param_props.addLong(""NUM_WRITE_THREADS"", ""1"");
    S_AXI_transactor_param_props.addLong(""RUSER_BITS_PER_BYTE"", ""0"");
    S_AXI_transactor_param_props.addLong(""WUSER_BITS_PER_BYTE"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_SIZE"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_RESET"", ""0"");
    S_AXI_transactor_param_props.addFloat(""PHASE"", ""0.000"");
    S_AXI_transactor_param_props.addString(""PROTOCOL"", ""AXI4LITE"");
    S_AXI_transactor_param_props.addString(""READ_WRITE_MODE"", ""READ_WRITE"");
    S_AXI_transactor_param_props.addString(""CLK_DOMAIN"", ""video_cp_ps7_0_0_FCLK_CLK0"");

    mp_S_AXI_transactor = new xtlm::xaximm_pin2xtlm_t<32,5,1,1,1,1,1,1>(""S_AXI_transactor"", S_AXI_transactor_param_props);

    // S_AXI' transactor ports

    mp_S_AXI_transactor->AWADDR(s_axi_awaddr);
    mp_S_AXI_transactor->AWPROT(s_axi_awprot);
    mp_S_AXI_transactor->AWVALID(s_axi_awvalid);
    mp_S_AXI_transactor->AWREADY(s_axi_awready);
    mp_S_AXI_transactor->WDATA(s_axi_wdata);
    mp_S_AXI_transactor->WSTRB(s_axi_wstrb);
    mp_S_AXI_transactor->WVALID(s_axi_wvalid);
    mp_S_AXI_transactor->WREADY(s_axi_wready);
    mp_S_AXI_transactor->BRESP(s_axi_bresp);
    mp_S_AXI_transactor->BVALID(s_axi_bvalid);
    mp_S_AXI_transactor->BREADY(s_axi_bready);
    mp_S_AXI_transactor->ARADDR(s_axi_araddr);
    mp_S_AXI_transactor->ARPROT(s_axi_arprot);
    mp_S_AXI_transactor->ARVALID(s_axi_arvalid);
    mp_S_AXI_transactor->ARREADY(s_axi_arready);
    mp_S_AXI_transactor->RDATA(s_axi_rdata);
    mp_S_AXI_transactor->RRESP(s_axi_rresp);
    mp_S_AXI_transactor->RVALID(s_axi_rvalid);
    mp_S_AXI_transactor->RREADY(s_axi_rready);
    mp_S_AXI_transactor->CLK(s_axi_aclk);
    m_S_AXI_transactor_rst_signal.write(1);
    mp_S_AXI_transactor->RST(m_S_AXI_transactor_rst_signal);

    // S_AXI' transactor sockets

    mp_impl->S_TARGET_rd_socket->bind(*(mp_S_AXI_transactor->rd_socket));
    mp_impl->S_TARGET_wr_socket->bind(*(mp_S_AXI_transactor->wr_socket));
  }
  else
  {
  }

  // configure 'M_AXI' transactor

  if (xsc::utils::xsc_sim_manager::getInstanceParameterInt(""video_cp_auto_cc_3"", ""M_AXI_TLM_MODE"") != 1)
  {
    // Instantiate Socket Stubs

  // 'M_AXI' transactor parameters
    xsc::common_cpp::properties M_AXI_transactor_param_props;
    M_AXI_transactor_param_props.addLong(""DATA_WIDTH"", ""32"");
    M_AXI_transactor_param_props.addLong(""FREQ_HZ"", ""142857132"");
    M_AXI_transactor_param_props.addLong(""ID_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""ADDR_WIDTH"", ""5"");
    M_AXI_transactor_param_props.addLong(""AWUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""ARUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""WUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""RUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""BUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_BURST"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_LOCK"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_PROT"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_CACHE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_QOS"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_REGION"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_WSTRB"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_BRESP"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_RRESP"", ""1"");
    M_AXI_transactor_param_props.addLong(""SUPPORTS_NARROW_BURST"", ""0"");
    M_AXI_transactor_param_props.addLong(""NUM_READ_OUTSTANDING"", ""8"");
    M_AXI_transactor_param_props.addLong(""NUM_WRITE_OUTSTANDING"", ""8"");
    M_AXI_transactor_param_props.addLong(""MAX_BURST_LENGTH"", ""1"");
    M_AXI_transactor_param_props.addLong(""NUM_READ_THREADS"", ""1"");
    M_AXI_transactor_param_props.addLong(""NUM_WRITE_THREADS"", ""1"");
    M_AXI_transactor_param_props.addLong(""RUSER_BITS_PER_BYTE"", ""0"");
    M_AXI_transactor_param_props.addLong(""WUSER_BITS_PER_BYTE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_SIZE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_RESET"", ""0"");
    M_AXI_transactor_param_props.addFloat(""PHASE"", ""0.000"");
    M_AXI_transactor_param_props.addString(""PROTOCOL"", ""AXI4LITE"");
    M_AXI_transactor_param_props.addString(""READ_WRITE_MODE"", ""READ_WRITE"");
    M_AXI_transactor_param_props.addString(""CLK_DOMAIN"", ""video_cp_ps7_0_0_FCLK_CLK1"");

    mp_M_AXI_transactor = new xtlm::xaximm_xtlm2pin_t<32,5,1,1,1,1,1,1>(""M_AXI_transactor"", M_AXI_transactor_param_props);

    // M_AXI' transactor ports

    mp_M_AXI_transactor->AWADDR(m_axi_awaddr);
    mp_M_AXI_transactor->AWPROT(m_axi_awprot);
    mp_M_AXI_transactor->AWVALID(m_axi_awvalid);
    mp_M_AXI_transactor->AWREADY(m_axi_awready);
    mp_M_AXI_transactor->WDATA(m_axi_wdata);
    mp_M_AXI_transactor->WSTRB(m_axi_wstrb);
    mp_M_AXI_transactor->WVALID(m_axi_wvalid);
    mp_M_AXI_transactor->WREADY(m_axi_wready);
    mp_M_AXI_transactor->BRESP(m_axi_bresp);
    mp_M_AXI_transactor->BVALID(m_axi_bvalid);
    mp_M_AXI_transactor->BREADY(m_axi_bready);
    mp_M_AXI_transactor->ARADDR(m_axi_araddr);
    mp_M_AXI_transactor->ARPROT(m_axi_arprot);
    mp_M_AXI_transactor->ARVALID(m_axi_arvalid);
    mp_M_AXI_transactor->ARREADY(m_axi_arready);
    mp_M_AXI_transactor->RDATA(m_axi_rdata);
    mp_M_AXI_transactor->RRESP(m_axi_rresp);
    mp_M_AXI_transactor->RVALID(m_axi_rvalid);
    mp_M_AXI_transactor->RREADY(m_axi_rready);
    mp_M_AXI_transactor->CLK(m_axi_aclk);
    m_M_AXI_transactor_rst_signal.write(1);
    mp_M_AXI_transactor->RST(m_M_AXI_transactor_rst_signal);

    // M_AXI' transactor sockets

    mp_impl->M_INITIATOR_rd_socket->bind(*(mp_M_AXI_transactor->rd_socket));
    mp_impl->M_INITIATOR_wr_socket->bind(*(mp_M_AXI_transactor->wr_socket));
  }
  else
  {
  }

}

#endif // RIVIERA




#ifdef VCSSYSTEMC
video_cp_auto_cc_3::video_cp_auto_cc_3(const sc_core::sc_module_name& nm) : video_cp_auto_cc_3_sc(nm),  s_axi_aclk(""s_axi_aclk""), s_axi_aresetn(""s_axi_aresetn""), s_axi_awaddr(""s_axi_awaddr""), s_axi_awprot(""s_axi_awprot""), s_axi_awvalid(""s_axi_awvalid""), s_axi_awready(""s_axi_awready""), s_axi_wdata(""s_axi_wdata""), s_axi_wstrb(""s_axi_wstrb""), s_axi_wvalid(""s_axi_wvalid""), s_axi_wready(""s_axi_wready""), s_axi_bresp(""s_axi_bresp""), s_axi_bvalid(""s_axi_bvalid""), s_axi_bready(""s_axi_bready""), s_axi_araddr(""s_axi_araddr""), s_axi_arprot(""s_axi_arprot""), s_axi_arvalid(""s_axi_arvalid""), s_axi_arready(""s_axi_arready""), s_axi_rdata(""s_axi_rdata""), s_axi_rresp(""s_axi_rresp""), s_axi_rvalid(""s_axi_rvalid""), s_axi_rready(""s_axi_rready""), m_axi_aclk(""m_axi_aclk""), m_axi_aresetn(""m_axi_aresetn""), m_axi_awaddr(""m_axi_awaddr""), m_axi_awprot(""m_axi_awprot""), m_axi_awvalid(""m_axi_awvalid""), m_axi_awready(""m_axi_awready""), m_axi_wdata(""m_axi_wdata""), m_axi_wstrb(""m_axi_wstrb""), m_axi_wvalid(""m_axi_wvalid""), m_axi_wready(""m_axi_wready""), m_axi_bresp(""m_axi_bresp""), m_axi_bvalid(""m_axi_bvalid""), m_axi_bready(""m_axi_bready""), m_axi_araddr(""m_axi_araddr""), m_axi_arprot(""m_axi_arprot""), m_axi_arvalid(""m_axi_arvalid""), m_axi_arready(""m_axi_arready""), m_axi_rdata(""m_axi_rdata""), m_axi_rresp(""m_axi_rresp""), m_axi_rvalid(""m_axi_rvalid""), m_axi_rready(""m_axi_rready"")
{
  // initialize pins
  mp_impl->s_axi_aclk(s_axi_aclk);
  mp_impl->s_axi_aresetn(s_axi_aresetn);
  mp_impl->m_axi_aclk(m_axi_aclk);
  mp_impl->m_axi_aresetn(m_axi_aresetn);

  // initialize transactors
  mp_S_AXI_transactor = NULL;
  mp_M_AXI_transactor = NULL;

  // Instantiate Socket Stubs

  // configure S_AXI_transactor
    xsc::common_cpp::properties S_AXI_transactor_param_props;
    S_AXI_transactor_param_props.addLong(""DATA_WIDTH"", ""32"");
    S_AXI_transactor_param_props.addLong(""FREQ_HZ"", ""100000000"");
    S_AXI_transactor_param_props.addLong(""ID_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""ADDR_WIDTH"", ""5"");
    S_AXI_transactor_param_props.addLong(""AWUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""ARUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""WUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""RUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""BUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_BURST"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_LOCK"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_PROT"", ""1"");
    S_AXI_transactor_param_props.addLong(""HAS_CACHE"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_QOS"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_REGION"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_WSTRB"", ""1"");
    S_AXI_transactor_param_props.addLong(""HAS_BRESP"", ""1"");
    S_AXI_transactor_param_props.addLong(""HAS_RRESP"", ""1"");
    S_AXI_transactor_param_props.addLong(""SUPPORTS_NARROW_BURST"", ""0"");
    S_AXI_transactor_param_props.addLong(""NUM_READ_OUTSTANDING"", ""8"");
    S_AXI_transactor_param_props.addLong(""NUM_WRITE_OUTSTANDING"", ""8"");
    S_AXI_transactor_param_props.addLong(""MAX_BURST_LENGTH"", ""1"");
    S_AXI_transactor_param_props.addLong(""NUM_READ_THREADS"", ""1"");
    S_AXI_transactor_param_props.addLong(""NUM_WRITE_THREADS"", ""1"");
    S_AXI_transactor_param_props.addLong(""RUSER_BITS_PER_BYTE"", ""0"");
    S_AXI_transactor_param_props.addLong(""WUSER_BITS_PER_BYTE"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_SIZE"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_RESET"", ""0"");
    S_AXI_transactor_param_props.addFloat(""PHASE"", ""0.000"");
    S_AXI_transactor_param_props.addString(""PROTOCOL"", ""AXI4LITE"");
    S_AXI_transactor_param_props.addString(""READ_WRITE_MODE"", ""READ_WRITE"");
    S_AXI_transactor_param_props.addString(""CLK_DOMAIN"", ""video_cp_ps7_0_0_FCLK_CLK0"");

    mp_S_AXI_transactor = new xtlm::xaximm_pin2xtlm_t<32,5,1,1,1,1,1,1>(""S_AXI_transactor"", S_AXI_transactor_param_props);
  mp_S_AXI_transactor->AWADDR(s_axi_awaddr);
  mp_S_AXI_transactor->AWPROT(s_axi_awprot);
  mp_S_AXI_transactor->AWVALID(s_axi_awvalid);
  mp_S_AXI_transactor->AWREADY(s_axi_awready);
  mp_S_AXI_transactor->WDATA(s_axi_wdata);
  mp_S_AXI_transactor->WSTRB(s_axi_wstrb);
  mp_S_AXI_transactor->WVALID(s_axi_wvalid);
  mp_S_AXI_transactor->WREADY(s_axi_wready);
  mp_S_AXI_transactor->BRESP(s_axi_bresp);
  mp_S_AXI_transactor->BVALID(s_axi_bvalid);
  mp_S_AXI_transactor->BREADY(s_axi_bready);
  mp_S_AXI_transactor->ARADDR(s_axi_araddr);
  mp_S_AXI_transactor->ARPROT(s_axi_arprot);
  mp_S_AXI_transactor->ARVALID(s_axi_arvalid);
  mp_S_AXI_transactor->ARREADY(s_axi_arready);
  mp_S_AXI_transactor->RDATA(s_axi_rdata);
  mp_S_AXI_transactor->RRESP(s_axi_rresp);
  mp_S_AXI_transactor->RVALID(s_axi_rvalid);
  mp_S_AXI_transactor->RREADY(s_axi_rready);
  mp_S_AXI_transactor->CLK(s_axi_aclk);
  m_S_AXI_transactor_rst_signal.write(1);
  mp_S_AXI_transactor->RST(m_S_AXI_transactor_rst_signal);
  // configure M_AXI_transactor
    xsc::common_cpp::properties M_AXI_transactor_param_props;
    M_AXI_transactor_param_props.addLong(""DATA_WIDTH"", ""32"");
    M_AXI_transactor_param_props.addLong(""FREQ_HZ"", ""142857132"");
    M_AXI_transactor_param_props.addLong(""ID_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""ADDR_WIDTH"", ""5"");
    M_AXI_transactor_param_props.addLong(""AWUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""ARUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""WUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""RUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""BUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_BURST"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_LOCK"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_PROT"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_CACHE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_QOS"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_REGION"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_WSTRB"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_BRESP"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_RRESP"", ""1"");
    M_AXI_transactor_param_props.addLong(""SUPPORTS_NARROW_BURST"", ""0"");
    M_AXI_transactor_param_props.addLong(""NUM_READ_OUTSTANDING"", ""8"");
    M_AXI_transactor_param_props.addLong(""NUM_WRITE_OUTSTANDING"", ""8"");
    M_AXI_transactor_param_props.addLong(""MAX_BURST_LENGTH"", ""1"");
    M_AXI_transactor_param_props.addLong(""NUM_READ_THREADS"", ""1"");
    M_AXI_transactor_param_props.addLong(""NUM_WRITE_THREADS"", ""1"");
    M_AXI_transactor_param_props.addLong(""RUSER_BITS_PER_BYTE"", ""0"");
    M_AXI_transactor_param_props.addLong(""WUSER_BITS_PER_BYTE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_SIZE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_RESET"", ""0"");
    M_AXI_transactor_param_props.addFloat(""PHASE"", ""0.000"");
    M_AXI_transactor_param_props.addString(""PROTOCOL"", ""AXI4LITE"");
    M_AXI_transactor_param_props.addString(""READ_WRITE_MODE"", ""READ_WRITE"");
    M_AXI_transactor_param_props.addString(""CLK_DOMAIN"", ""video_cp_ps7_0_0_FCLK_CLK1"");

    mp_M_AXI_transactor = new xtlm::xaximm_xtlm2pin_t<32,5,1,1,1,1,1,1>(""M_AXI_transactor"", M_AXI_transactor_param_props);
  mp_M_AXI_transactor->AWADDR(m_axi_awaddr);
  mp_M_AXI_transactor->AWPROT(m_axi_awprot);
  mp_M_AXI_transactor->AWVALID(m_axi_awvalid);
  mp_M_AXI_transactor->AWREADY(m_axi_awready);
  mp_M_AXI_transactor->WDATA(m_axi_wdata);
  mp_M_AXI_transactor->WSTRB(m_axi_wstrb);
  mp_M_AXI_transactor->WVALID(m_axi_wvalid);
  mp_M_AXI_transactor->WREADY(m_axi_wready);
  mp_M_AXI_transactor->BRESP(m_axi_bresp);
  mp_M_AXI_transactor->BVALID(m_axi_bvalid);
  mp_M_AXI_transactor->BREADY(m_axi_bready);
  mp_M_AXI_transactor->ARADDR(m_axi_araddr);
  mp_M_AXI_transactor->ARPROT(m_axi_arprot);
  mp_M_AXI_transactor->ARVALID(m_axi_arvalid);
  mp_M_AXI_transactor->ARREADY(m_axi_arready);
  mp_M_AXI_transactor->RDATA(m_axi_rdata);
  mp_M_AXI_transactor->RRESP(m_axi_rresp);
  mp_M_AXI_transactor->RVALID(m_axi_rvalid);
  mp_M_AXI_transactor->RREADY(m_axi_rready);
  mp_M_AXI_transactor->CLK(m_axi_aclk);
  m_M_AXI_transactor_rst_signal.write(1);
  mp_M_AXI_transactor->RST(m_M_AXI_transactor_rst_signal);

  // initialize transactors stubs
  S_AXI_transactor_target_wr_socket_stub = nullptr;
  S_AXI_transactor_target_rd_socket_stub = nullptr;
  M_AXI_transactor_initiator_wr_socket_stub = nullptr;
  M_AXI_transactor_initiator_rd_socket_stub = nullptr;

}

void video_cp_auto_cc_3::before_end_of_elaboration()
{
  // configure 'S_AXI' transactor
  if (xsc::utils::xsc_sim_manager::getInstanceParameterInt(""video_cp_auto_cc_3"", ""S_AXI_TLM_MODE"") != 1)
  {
    mp_impl->S_TARGET_rd_socket->bind(*(mp_S_AXI_transactor->rd_socket));
    mp_impl->S_TARGET_wr_socket->bind(*(mp_S_AXI_transactor->wr_socket));
  
  }
  else
  {
    S_AXI_transactor_target_wr_socket_stub = new xtlm::xtlm_aximm_target_stub(""wr_socket"",0);
    S_AXI_transactor_target_wr_socket_stub->bind(*(mp_S_AXI_transactor->wr_socket));
    S_AXI_transactor_target_rd_socket_stub = new xtlm::xtlm_aximm_target_stub(""rd_socket"",0);
    S_AXI_transactor_target_rd_socket_stub->bind(*(mp_S_AXI_transactor->rd_socket));
    mp_S_AXI_transactor->disable_transactor();
  }

  // configure 'M_AXI' transactor
  if (xsc::utils::xsc_sim_manager::getInstanceParameterInt(""video_cp_auto_cc_3"", ""M_AXI_TLM_MODE"") != 1)
  {
    mp_impl->M_INITIATOR_rd_socket->bind(*(mp_M_AXI_transactor->rd_socket));
    mp_impl->M_INITIATOR_wr_socket->bind(*(mp_M_AXI_transactor->wr_socket));
  
  }
  else
  {
    M_AXI_transactor_initiator_wr_socket_stub = new xtlm::xtlm_aximm_initiator_stub(""wr_socket"",0);
    M_AXI_transactor_initiator_wr_socket_stub->bind(*(mp_M_AXI_transactor->wr_socket));
    M_AXI_transactor_initiator_rd_socket_stub = new xtlm::xtlm_aximm_initiator_stub(""rd_socket"",0);
    M_AXI_transactor_initiator_rd_socket_stub->bind(*(mp_M_AXI_transactor->rd_socket));
    mp_M_AXI_transactor->disable_transactor();
  }

}

#endif // VCSSYSTEMC




#ifdef MTI_SYSTEMC
video_cp_auto_cc_3::video_cp_auto_cc_3(const sc_core::sc_module_name& nm) : video_cp_auto_cc_3_sc(nm),  s_axi_aclk(""s_axi_aclk""), s_axi_aresetn(""s_axi_aresetn""), s_axi_awaddr(""s_axi_awaddr""), s_axi_awprot(""s_axi_awprot""), s_axi_awvalid(""s_axi_awvalid""), s_axi_awready(""s_axi_awready""), s_axi_wdata(""s_axi_wdata""), s_axi_wstrb(""s_axi_wstrb""), s_axi_wvalid(""s_axi_wvalid""), s_axi_wready(""s_axi_wready""), s_axi_bresp(""s_axi_bresp""), s_axi_bvalid(""s_axi_bvalid""), s_axi_bready(""s_axi_bready""), s_axi_araddr(""s_axi_araddr""), s_axi_arprot(""s_axi_arprot""), s_axi_arvalid(""s_axi_arvalid""), s_axi_arready(""s_axi_arready""), s_axi_rdata(""s_axi_rdata""), s_axi_rresp(""s_axi_rresp""), s_axi_rvalid(""s_axi_rvalid""), s_axi_rready(""s_axi_rready""), m_axi_aclk(""m_axi_aclk""), m_axi_aresetn(""m_axi_aresetn""), m_axi_awaddr(""m_axi_awaddr""), m_axi_awprot(""m_axi_awprot""), m_axi_awvalid(""m_axi_awvalid""), m_axi_awready(""m_axi_awready""), m_axi_wdata(""m_axi_wdata""), m_axi_wstrb(""m_axi_wstrb""), m_axi_wvalid(""m_axi_wvalid""), m_axi_wready(""m_axi_wready""), m_axi_bresp(""m_axi_bresp""), m_axi_bvalid(""m_axi_bvalid""), m_axi_bready(""m_axi_bready""), m_axi_araddr(""m_axi_araddr""), m_axi_arprot(""m_axi_arprot""), m_axi_arvalid(""m_axi_arvalid""), m_axi_arready(""m_axi_arready""), m_axi_rdata(""m_axi_rdata""), m_axi_rresp(""m_axi_rresp""), m_axi_rvalid(""m_axi_rvalid""), m_axi_rready(""m_axi_rready"")
{
  // initialize pins
  mp_impl->s_axi_aclk(s_axi_aclk);
  mp_impl->s_axi_aresetn(s_axi_aresetn);
  mp_impl->m_axi_aclk(m_axi_aclk);
  mp_impl->m_axi_aresetn(m_axi_aresetn);

  // initialize transactors
  mp_S_AXI_transactor = NULL;
  mp_M_AXI_transactor = NULL;

  // Instantiate Socket Stubs

  // configure S_AXI_transactor
    xsc::common_cpp::properties S_AXI_transactor_param_props;
    S_AXI_transactor_param_props.addLong(""DATA_WIDTH"", ""32"");
    S_AXI_transactor_param_props.addLong(""FREQ_HZ"", ""100000000"");
    S_AXI_transactor_param_props.addLong(""ID_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""ADDR_WIDTH"", ""5"");
    S_AXI_transactor_param_props.addLong(""AWUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""ARUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""WUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""RUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""BUSER_WIDTH"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_BURST"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_LOCK"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_PROT"", ""1"");
    S_AXI_transactor_param_props.addLong(""HAS_CACHE"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_QOS"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_REGION"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_WSTRB"", ""1"");
    S_AXI_transactor_param_props.addLong(""HAS_BRESP"", ""1"");
    S_AXI_transactor_param_props.addLong(""HAS_RRESP"", ""1"");
    S_AXI_transactor_param_props.addLong(""SUPPORTS_NARROW_BURST"", ""0"");
    S_AXI_transactor_param_props.addLong(""NUM_READ_OUTSTANDING"", ""8"");
    S_AXI_transactor_param_props.addLong(""NUM_WRITE_OUTSTANDING"", ""8"");
    S_AXI_transactor_param_props.addLong(""MAX_BURST_LENGTH"", ""1"");
    S_AXI_transactor_param_props.addLong(""NUM_READ_THREADS"", ""1"");
    S_AXI_transactor_param_props.addLong(""NUM_WRITE_THREADS"", ""1"");
    S_AXI_transactor_param_props.addLong(""RUSER_BITS_PER_BYTE"", ""0"");
    S_AXI_transactor_param_props.addLong(""WUSER_BITS_PER_BYTE"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_SIZE"", ""0"");
    S_AXI_transactor_param_props.addLong(""HAS_RESET"", ""0"");
    S_AXI_transactor_param_props.addFloat(""PHASE"", ""0.000"");
    S_AXI_transactor_param_props.addString(""PROTOCOL"", ""AXI4LITE"");
    S_AXI_transactor_param_props.addString(""READ_WRITE_MODE"", ""READ_WRITE"");
    S_AXI_transactor_param_props.addString(""CLK_DOMAIN"", ""video_cp_ps7_0_0_FCLK_CLK0"");

    mp_S_AXI_transactor = new xtlm::xaximm_pin2xtlm_t<32,5,1,1,1,1,1,1>(""S_AXI_transactor"", S_AXI_transactor_param_props);
  mp_S_AXI_transactor->AWADDR(s_axi_awaddr);
  mp_S_AXI_transactor->AWPROT(s_axi_awprot);
  mp_S_AXI_transactor->AWVALID(s_axi_awvalid);
  mp_S_AXI_transactor->AWREADY(s_axi_awready);
  mp_S_AXI_transactor->WDATA(s_axi_wdata);
  mp_S_AXI_transactor->WSTRB(s_axi_wstrb);
  mp_S_AXI_transactor->WVALID(s_axi_wvalid);
  mp_S_AXI_transactor->WREADY(s_axi_wready);
  mp_S_AXI_transactor->BRESP(s_axi_bresp);
  mp_S_AXI_transactor->BVALID(s_axi_bvalid);
  mp_S_AXI_transactor->BREADY(s_axi_bready);
  mp_S_AXI_transactor->ARADDR(s_axi_araddr);
  mp_S_AXI_transactor->ARPROT(s_axi_arprot);
  mp_S_AXI_transactor->ARVALID(s_axi_arvalid);
  mp_S_AXI_transactor->ARREADY(s_axi_arready);
  mp_S_AXI_transactor->RDATA(s_axi_rdata);
  mp_S_AXI_transactor->RRESP(s_axi_rresp);
  mp_S_AXI_transactor->RVALID(s_axi_rvalid);
  mp_S_AXI_transactor->RREADY(s_axi_rready);
  mp_S_AXI_transactor->CLK(s_axi_aclk);
  m_S_AXI_transactor_rst_signal.write(1);
  mp_S_AXI_transactor->RST(m_S_AXI_transactor_rst_signal);
  // configure M_AXI_transactor
    xsc::common_cpp::properties M_AXI_transactor_param_props;
    M_AXI_transactor_param_props.addLong(""DATA_WIDTH"", ""32"");
    M_AXI_transactor_param_props.addLong(""FREQ_HZ"", ""142857132"");
    M_AXI_transactor_param_props.addLong(""ID_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""ADDR_WIDTH"", ""5"");
    M_AXI_transactor_param_props.addLong(""AWUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""ARUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""WUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""RUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""BUSER_WIDTH"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_BURST"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_LOCK"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_PROT"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_CACHE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_QOS"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_REGION"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_WSTRB"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_BRESP"", ""1"");
    M_AXI_transactor_param_props.addLong(""HAS_RRESP"", ""1"");
    M_AXI_transactor_param_props.addLong(""SUPPORTS_NARROW_BURST"", ""0"");
    M_AXI_transactor_param_props.addLong(""NUM_READ_OUTSTANDING"", ""8"");
    M_AXI_transactor_param_props.addLong(""NUM_WRITE_OUTSTANDING"", ""8"");
    M_AXI_transactor_param_props.addLong(""MAX_BURST_LENGTH"", ""1"");
    M_AXI_transactor_param_props.addLong(""NUM_READ_THREADS"", ""1"");
    M_AXI_transactor_param_props.addLong(""NUM_WRITE_THREADS"", ""1"");
    M_AXI_transactor_param_props.addLong(""RUSER_BITS_PER_BYTE"", ""0"");
    M_AXI_transactor_param_props.addLong(""WUSER_BITS_PER_BYTE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_SIZE"", ""0"");
    M_AXI_transactor_param_props.addLong(""HAS_RESET"", ""0"");
    M_AXI_transactor_param_props.addFloat(""PHASE"", ""0.000"");
    M_AXI_transactor_param_props.addString(""PROTOCOL"", ""AXI4LITE"");
    M_AXI_transactor_param_props.addString(""READ_WRITE_MODE"", ""READ_WRITE"");
    M_AXI_transactor_param_props.addString(""CLK_DOMAIN"", ""video_cp_ps7_0_0_FCLK_CLK1"");

    mp_M_AXI_transactor = new xtlm::xaximm_xtlm2pin_t<32,5,1,1,1,1,1,1>(""M_AXI_transactor"", M_AXI_transactor_param_props);
  mp_M_AXI_transactor->AWADDR(m_axi_awaddr);
  mp_M_AXI_transactor->AWPROT(m_axi_awprot);
  mp_M_AXI_transactor->AWVALID(m_axi_awvalid);
  mp_M_AXI_transactor->AWREADY(m_axi_awready);
  mp_M_AXI_transactor->WDATA(m_axi_wdata);
  mp_M_AXI_transactor->WSTRB(m_axi_wstrb);
  mp_M_AXI_transactor->WVALID(m_axi_wvalid);
  mp_M_AXI_transactor->WREADY(m_axi_wready);
  mp_M_AXI_transactor->BRESP(m_axi_bresp);
  mp_M_AXI_transactor->BVALID(m_axi_bvalid);
  mp_M_AXI_transactor->BREADY(m_axi_bready);
  mp_M_AXI_transactor->ARADDR(m_axi_araddr);
  mp_M_AXI_transactor->ARPROT(m_axi_arprot);
  mp_M_AXI_transactor->ARVALID(m_axi_arvalid);
  mp_M_AXI_transactor->ARREADY(m_axi_arready);
  mp_M_AXI_transactor->RDATA(m_axi_rdata);
  mp_M_AXI_transactor->RRESP(m_axi_rresp);
  mp_M_AXI_transactor->RVALID(m_axi_rvalid);
  mp_M_AXI_transactor->RREADY(m_axi_rready);
  mp_M_AXI_transactor->CLK(m_axi_aclk);
  m_M_AXI_transactor_rst_signal.write(1);
  mp_M_AXI_transactor->RST(m_M_AXI_transactor_rst_signal);

  // initialize transactors stubs
  S_AXI_transactor_target_wr_socket_stub = nullptr;
  S_AXI_transactor_target_rd_socket_stub = nullptr;
  M_AXI_transactor_initiator_wr_socket_stub = nullptr;
  M_AXI_transactor_initiator_rd_socket_stub = nullptr;

}

void video_cp_auto_cc_3::before_end_of_elaboration()
{
  // configure 'S_AXI' transactor
  if (xsc::utils::xsc_sim_manager::getInstanceParameterInt(""video_cp_auto_cc_3"", ""S_AXI_TLM_MODE"") != 1)
  {
    mp_impl->S_TARGET_rd_socket->bind(*(mp_S_AXI_transactor->rd_socket));
    mp_impl->S_TARGET_wr_socket->bind(*(mp_S_AXI_transactor->wr_socket));
  
  }
  else
  {
    S_AXI_transactor_target_wr_socket_stub = new xtlm::xtlm_aximm_target_stub(""wr_socket"",0);
    S_AXI_transactor_target_wr_socket_stub->bind(*(mp_S_AXI_transactor->wr_socket));
    S_AXI_transactor_target_rd_socket_stub = new xtlm::xtlm_aximm_target_stub(""rd_socket"",0);
    S_AXI_transactor_target_rd_socket_stub->bind(*(mp_S_AXI_transactor->rd_socket));
    mp_S_AXI_transactor->disable_transactor();
  }

  // configure 'M_AXI' transactor
  if (xsc::utils::xsc_sim_manager::getInstanceParameterInt(""video_cp_auto_cc_3"", ""M_AXI_TLM_MODE"") != 1)
  {
    mp_impl->M_INITIATOR_rd_socket->bind(*(mp_M_AXI_transactor->rd_socket));
    mp_impl->M_INITIATOR_wr_socket->bind(*(mp_M_AXI_transactor->wr_socket));
  
  }
  else
  {
    M_AXI_transactor_initiator_wr_socket_stub = new xtlm::xtlm_aximm_initiator_stub(""wr_socket"",0);
    M_AXI_transactor_initiator_wr_socket_stub->bind(*(mp_M_AXI_transactor->wr_socket));
    M_AXI_transactor_initiator_rd_socket_stub = new xtlm::xtlm_aximm_initiator_stub(""rd_socket"",0);
    M_AXI_transactor_initiator_rd_socket_stub->bind(*(mp_M_AXI_transactor->rd_socket));
    mp_M_AXI_transactor->disable_transactor();
  }

}

#endif // MTI_SYSTEMC




video_cp_auto_cc_3::~video_cp_auto_cc_3()
{
  delete mp_S_AXI_transactor;

  delete mp_M_AXI_transactor;

}

#ifdef MTI_SYSTEMC
SC_MODULE_EXPORT(video_cp_auto_cc_3);
#endif

#ifdef XM_SYSTEMC
XMSC_MODULE_EXPORT(video_cp_auto_cc_3);
#endif

#ifdef RIVIERA
SC_MODULE_EXPORT(video_cp_auto_cc_3);
#endif

",16295,True,4797.412796352302,median
"== [[functions]] Standard Functions -- functions Object

`org.apache.spark.sql.functions` object defines many built-in functions to work with link:spark-sql-Column.adoc[Columns] in link:spark-sql-Dataset.adoc[Datasets].

You can access the functions using the following `import` statement:

[source, scala]
----
import org.apache.spark.sql.functions._
----

There are over 200 functions in the `functions` object.

```
scala> spark.catalog.listFunctions.count
res1: Long = 251
```

[[standard-functions]]
.(Subset of) Standard Functions in Spark SQL
[align=""center"",cols=""1,1,2"",width=""100%"",options=""header""]
|===
|
|Name
|Description

.3+^.^| [[aggregate-functions]] *Aggregate functions*

| <<count, count>>
|

| <<grouping, grouping>>
| Indicates whether a specified column is aggregated or not

| <<grouping_id, grouping_id>>
| Computes the level of grouping

.3+^.^| *Collection functions*

| <<explode, explode>>
|

| <<explode_outer, explode_outer>>
| *(new in 2.2.0)* Creates a new row for each element in the given array or map column.

If the array/map is `null` or empty then `null` is produced.

| <<from_json, from_json>>
| Parses a column with a JSON string into a link:spark-sql-StructType.adoc[StructType] or link:spark-sql-DataType.adoc#ArrayType[ArrayType] of `StructType` elements with the specified schema.

.5+^.^| *Date and time functions*
| link:spark-sql-functions-datetime.adoc#current_timestamp[current_timestamp]
|

| link:spark-sql-functions-datetime.adoc#to_date[to_date]
|

| link:spark-sql-functions-datetime.adoc#to_timestamp[to_timestamp]
|

| link:spark-sql-functions-datetime.adoc#unix_timestamp[unix_timestamp]
| Converts current or specified time to Unix timestamp (in seconds)

| link:spark-sql-functions-datetime.adoc#window[window]
| Generates tumbling time windows

1+^.^| *Math functions*
| <<bin, bin>>
| Converts the value of a long column to binary format

.4+^.^| *Regular functions*

| <<broadcast, broadcast>>
|

| <<creating-columns, col>> and <<creating-columns, column>>
| Creating link:spark-sql-Column.adoc[Columns]

| <<expr, expr>>
|

| <<struct, struct>>
|

.2+^.^| *String functions*
| <<split, split>>
|

| <<upper, upper>>
|

1+^.^| *UDF functions*
| <<udf, udf>>
| Creating UDFs

.6+^.^|*Window functions*
|<<rank, rank, dense_rank, percent_rank>>
| Ranking records per window partition

| <<ntile, ntile>>
| Gives the ntile group if (from `1` to `n` inclusive) in an ordered window partition

|<<row_number, row_number>>
| Sequential numbering per window partition

|<<cume_dist, cume_dist>>
| Cumulative distribution of records across window partitions

|<<lag, lag>>
|

|<<lead, lead>>
|
|===

TIP: The page gives only a brief ovierview of the many functions available in `functions` object and so you should read the http://spark.apache.org/docs/latest/api/scala/index.html#org.apache.spark.sql.functions$[official documentation of the `functions` object].

=== [[count]] `count` Function

CAUTION: FIXME

=== [[explode_outer]] `explode_outer` Function

[source, scala]
----
explode_outer(e: Column): Column
----

`explode_outer` generates a new row for each element in `e` array or map column.

NOTE: Unlike <<explode, explode>>, `explode_outer` generates `null` when the array or map is `null` or empty.

[source, scala]
----
val arrays = Seq((1,Seq.empty[String])).toDF(""id"", ""array"")
scala> arrays.printSchema
root
 |-- id: integer (nullable = false)
 |-- array: array (nullable = true)
 |    |-- element: string (containsNull = true)
scala> arrays.select(explode_outer($""array"")).show
+----+
| col|
+----+
|null|
+----+
----

Internally, `explode_outer` creates a link:spark-sql-Column.adoc[Column] with link:spark-sql-Expression-Generator.adoc#GeneratorOuter[GeneratorOuter] and link:spark-sql-Expression-Generator.adoc#Explode[Explode] Catalyst expressions.

[source, scala]
----
val explodeOuter = explode_outer($""array"").expr
scala> println(explodeOuter.numberedTreeString)
00 generatorouter(explode('array))
01 +- explode('array)
02    +- 'array
----

=== [[explode]] `explode` Function

CAUTION: FIXME

[source, scala]
----
scala> Seq(Array(0,1,2)).toDF(""array"").withColumn(""num"", explode('array)).show
+---------+---+
|    array|num|
+---------+---+
|[0, 1, 2]|  0|
|[0, 1, 2]|  1|
|[0, 1, 2]|  2|
+---------+---+
----

NOTE: `explode` function is an equivalent of link:spark-sql-dataset-operators.adoc#flatMap[`flatMap` operator] for `Dataset`.

=== [[rank]][[dense_rank]][[percent_rank]] Ranking Records per Window Partition -- `rank` Function

[source, scala]
----
rank(): Column
dense_rank(): Column
percent_rank(): Column
----

`rank` functions assign the sequential rank of each distinct value per window partition. They are equivalent to `RANK`, `DENSE_RANK` and `PERCENT_RANK` functions in the good ol' SQL.

[source, scala]
----
val dataset = spark.range(9).withColumn(""bucket"", 'id % 3)

import org.apache.spark.sql.expressions.Window
val byBucket = Window.partitionBy('bucket).orderBy('id)

scala> dataset.withColumn(""rank"", rank over byBucket).show
+---+------+----+
| id|bucket|rank|
+---+------+----+
|  0|     0|   1|
|  3|     0|   2|
|  6|     0|   3|
|  1|     1|   1|
|  4|     1|   2|
|  7|     1|   3|
|  2|     2|   1|
|  5|     2|   2|
|  8|     2|   3|
+---+------+----+

scala> dataset.withColumn(""percent_rank"", percent_rank over byBucket).show
+---+------+------------+
| id|bucket|percent_rank|
+---+------+------------+
|  0|     0|         0.0|
|  3|     0|         0.5|
|  6|     0|         1.0|
|  1|     1|         0.0|
|  4|     1|         0.5|
|  7|     1|         1.0|
|  2|     2|         0.0|
|  5|     2|         0.5|
|  8|     2|         1.0|
+---+------+------------+
----

`rank` function assigns the same rank for duplicate rows with a gap in the sequence (similarly to Olympic medal places). `dense_rank` is like `rank` for duplicate rows but compacts the ranks and removes the gaps.

[source, scala]
----
// rank function with duplicates
// Note the missing/sparse ranks, i.e. 2 and 4
scala> dataset.union(dataset).withColumn(""rank"", rank over byBucket).show
+---+------+----+
| id|bucket|rank|
+---+------+----+
|  0|     0|   1|
|  0|     0|   1|
|  3|     0|   3|
|  3|     0|   3|
|  6|     0|   5|
|  6|     0|   5|
|  1|     1|   1|
|  1|     1|   1|
|  4|     1|   3|
|  4|     1|   3|
|  7|     1|   5|
|  7|     1|   5|
|  2|     2|   1|
|  2|     2|   1|
|  5|     2|   3|
|  5|     2|   3|
|  8|     2|   5|
|  8|     2|   5|
+---+------+----+

// dense_rank function with duplicates
// Note that the missing ranks are now filled in
scala> dataset.union(dataset).withColumn(""dense_rank"", dense_rank over byBucket).show
+---+------+----------+
| id|bucket|dense_rank|
+---+------+----------+
|  0|     0|         1|
|  0|     0|         1|
|  3|     0|         2|
|  3|     0|         2|
|  6|     0|         3|
|  6|     0|         3|
|  1|     1|         1|
|  1|     1|         1|
|  4|     1|         2|
|  4|     1|         2|
|  7|     1|         3|
|  7|     1|         3|
|  2|     2|         1|
|  2|     2|         1|
|  5|     2|         2|
|  5|     2|         2|
|  8|     2|         3|
|  8|     2|         3|
+---+------+----------+

// percent_rank function with duplicates
scala> dataset.union(dataset).withColumn(""percent_rank"", percent_rank over byBucket).show
+---+------+------------+
| id|bucket|percent_rank|
+---+------+------------+
|  0|     0|         0.0|
|  0|     0|         0.0|
|  3|     0|         0.4|
|  3|     0|         0.4|
|  6|     0|         0.8|
|  6|     0|         0.8|
|  1|     1|         0.0|
|  1|     1|         0.0|
|  4|     1|         0.4|
|  4|     1|         0.4|
|  7|     1|         0.8|
|  7|     1|         0.8|
|  2|     2|         0.0|
|  2|     2|         0.0|
|  5|     2|         0.4|
|  5|     2|         0.4|
|  8|     2|         0.8|
|  8|     2|         0.8|
+---+------+------------+
----

=== [[cume_dist]] Cumulative Distribution of Records Across Window Partitions -- `cume_dist` Function

[source, scala]
----
cume_dist(): Column
----

`cume_dist` computes the cumulative distribution of the records in window partitions. This is equivalent to SQL's `CUME_DIST` function.

[source, scala]
----
val buckets = spark.range(9).withColumn(""bucket"", 'id % 3)
// Make duplicates
val dataset = buckets.union(buckets)

import org.apache.spark.sql.expressions.Window
val windowSpec = Window.partitionBy('bucket).orderBy('id)
scala> dataset.withColumn(""cume_dist"", cume_dist over windowSpec).show
+---+------+------------------+
| id|bucket|         cume_dist|
+---+------+------------------+
|  0|     0|0.3333333333333333|
|  3|     0|0.6666666666666666|
|  6|     0|               1.0|
|  1|     1|0.3333333333333333|
|  4|     1|0.6666666666666666|
|  7|     1|               1.0|
|  2|     2|0.3333333333333333|
|  5|     2|0.6666666666666666|
|  8|     2|               1.0|
+---+------+------------------+
----

=== [[lag]] `lag` Function

[source, scala]
----
lag(e: Column, offset: Int): Column
lag(columnName: String, offset: Int): Column
lag(columnName: String, offset: Int, defaultValue: Any): Column
lag(e: Column, offset: Int, defaultValue: Any): Column
----

`lag` returns the value in `e` / `columnName` column that is `offset` records before the current record. `lag` returns `null` value if the number of records in a window partition is less than `offset` or `defaultValue`.

[source, scala]
----
val buckets = spark.range(9).withColumn(""bucket"", 'id % 3)
// Make duplicates
val dataset = buckets.union(buckets)

import org.apache.spark.sql.expressions.Window
val windowSpec = Window.partitionBy('bucket).orderBy('id)
scala> dataset.withColumn(""lag"", lag('id, 1) over windowSpec).show
+---+------+----+
| id|bucket| lag|
+---+------+----+
|  0|     0|null|
|  3|     0|   0|
|  6|     0|   3|
|  1|     1|null|
|  4|     1|   1|
|  7|     1|   4|
|  2|     2|null|
|  5|     2|   2|
|  8|     2|   5|
+---+------+----+

scala> dataset.withColumn(""lag"", lag('id, 2, ""<default_value>"") over windowSpec).show
+---+------+----+
| id|bucket| lag|
+---+------+----+
|  0|     0|null|
|  3|     0|null|
|  6|     0|   0|
|  1|     1|null|
|  4|     1|null|
|  7|     1|   1|
|  2|     2|null|
|  5|     2|null|
|  8|     2|   2|
+---+------+----+
----

CAUTION: FIXME It looks like `lag` with a default value has a bug -- the default value's not used at all.

=== [[lead]] `lead` Function

[source, scala]
----
lead(columnName: String, offset: Int): Column
lead(e: Column, offset: Int): Column
lead(columnName: String, offset: Int, defaultValue: Any): Column
lead(e: Column, offset: Int, defaultValue: Any): Column
----

`lead` returns the value that is `offset` records after the current records, and `defaultValue` if there is less than `offset` records after the current record. `lag` returns `null` value if the number of records in a window partition is less than `offset` or `defaultValue`.

[source, scala]
----
val buckets = spark.range(9).withColumn(""bucket"", 'id % 3)
// Make duplicates
val dataset = buckets.union(buckets)

import org.apache.spark.sql.expressions.Window
val windowSpec = Window.partitionBy('bucket).orderBy('id)
scala> dataset.withColumn(""lead"", lead('id, 1) over windowSpec).show
+---+------+----+
| id|bucket|lead|
+---+------+----+
|  0|     0|   0|
|  0|     0|   3|
|  3|     0|   3|
|  3|     0|   6|
|  6|     0|   6|
|  6|     0|null|
|  1|     1|   1|
|  1|     1|   4|
|  4|     1|   4|
|  4|     1|   7|
|  7|     1|   7|
|  7|     1|null|
|  2|     2|   2|
|  2|     2|   5|
|  5|     2|   5|
|  5|     2|   8|
|  8|     2|   8|
|  8|     2|null|
+---+------+----+

scala> dataset.withColumn(""lead"", lead('id, 2, ""<default_value>"") over windowSpec).show
+---+------+----+
| id|bucket|lead|
+---+------+----+
|  0|     0|   3|
|  0|     0|   3|
|  3|     0|   6|
|  3|     0|   6|
|  6|     0|null|
|  6|     0|null|
|  1|     1|   4|
|  1|     1|   4|
|  4|     1|   7|
|  4|     1|   7|
|  7|     1|null|
|  7|     1|null|
|  2|     2|   5|
|  2|     2|   5|
|  5|     2|   8|
|  5|     2|   8|
|  8|     2|null|
|  8|     2|null|
+---+------+----+
----

CAUTION: FIXME It looks like `lead` with a default value has a bug -- the default value's not used at all.

=== [[row_number]] Sequential numbering per window partition -- `row_number` Function

[source, scala]
----
row_number(): Column
----

`row_number` returns a sequential number starting at `1` within a window partition.

[source, scala]
----
val buckets = spark.range(9).withColumn(""bucket"", 'id % 3)
// Make duplicates
val dataset = buckets.union(buckets)

import org.apache.spark.sql.expressions.Window
val windowSpec = Window.partitionBy('bucket).orderBy('id)
scala> dataset.withColumn(""row_number"", row_number() over windowSpec).show
+---+------+----------+
| id|bucket|row_number|
+---+------+----------+
|  0|     0|         1|
|  0|     0|         2|
|  3|     0|         3|
|  3|     0|         4|
|  6|     0|         5|
|  6|     0|         6|
|  1|     1|         1|
|  1|     1|         2|
|  4|     1|         3|
|  4|     1|         4|
|  7|     1|         5|
|  7|     1|         6|
|  2|     2|         1|
|  2|     2|         2|
|  5|     2|         3|
|  5|     2|         4|
|  8|     2|         5|
|  8|     2|         6|
+---+------+----------+
----

=== [[ntile]] `ntile` Function

[source, scala]
----
ntile(n: Int): Column
----

`ntile` computes the ntile group id (from `1` to `n` inclusive) in an ordered window partition.

[source, scala]
----
val dataset = spark.range(7).select('*, 'id % 3 as ""bucket"")

import org.apache.spark.sql.expressions.Window
val byBuckets = Window.partitionBy('bucket).orderBy('id)
scala> dataset.select('*, ntile(3) over byBuckets as ""ntile"").show
+---+------+-----+
| id|bucket|ntile|
+---+------+-----+
|  0|     0|    1|
|  3|     0|    2|
|  6|     0|    3|
|  1|     1|    1|
|  4|     1|    2|
|  2|     2|    1|
|  5|     2|    2|
+---+------+-----+
----

CAUTION: FIXME How is `ntile` different from `rank`? What about performance?

=== [[creating-columns]][[col]][[column]] Creating Columns -- `col` and `column` Functions

[source, scala]
----
col(colName: String): Column
column(colName: String): Column
----

`col` and `column` methods create a link:spark-sql-Column.adoc[Column] that you can later use to reference a column in a dataset.

[source, scala]
----
import org.apache.spark.sql.functions._

scala> val nameCol = col(""name"")
nameCol: org.apache.spark.sql.Column = name

scala> val cityCol = column(""city"")
cityCol: org.apache.spark.sql.Column = city
----

=== [[udf]] Defining UDFs -- `udf` Function

[source, scala]
----
udf(f: FunctionN[...]): UserDefinedFunction
----

The `udf` family of functions allows you to create link:spark-sql-udfs.adoc[user-defined functions (UDFs)] based on a user-defined function in Scala. It accepts `f` function of 0 to 10 arguments and the input and output types are automatically inferred (given the types of the respective input and output types of the function `f`).

[source, scala]
----
import org.apache.spark.sql.functions._
val _length: String => Int = _.length
val _lengthUDF = udf(_length)

// define a dataframe
val df = sc.parallelize(0 to 3).toDF(""num"")

// apply the user-defined function to ""num"" column
scala> df.withColumn(""len"", _lengthUDF($""num"")).show
+---+---+
|num|len|
+---+---+
|  0|  1|
|  1|  1|
|  2|  1|
|  3|  1|
+---+---+
----

Since Spark 2.0.0, there is another variant of `udf` function:

[source, scala]
----
udf(f: AnyRef, dataType: DataType): UserDefinedFunction
----

`udf(f: AnyRef, dataType: DataType)` allows you to use a Scala closure for the function argument (as `f`) and explicitly declaring the output data type (as `dataType`).

[source, scala]
----
// given the dataframe above

import org.apache.spark.sql.types.IntegerType
val byTwo = udf((n: Int) => n * 2, IntegerType)

scala> df.withColumn(""len"", byTwo($""num"")).show
+---+---+
|num|len|
+---+---+
|  0|  0|
|  1|  2|
|  2|  4|
|  3|  6|
+---+---+
----

=== [[split]] `split` Function

[source, scala]
----
split(str: Column, pattern: String): Column
----

`split` function splits `str` column using `pattern`. It returns a new `Column`.

NOTE: `split` UDF uses https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#split-java.lang.String-int-[java.lang.String.split(String regex, int limit)] method.

[source, scala]
----
val df = Seq((0, ""hello|world""), (1, ""witaj|swiecie"")).toDF(""num"", ""input"")
val withSplit = df.withColumn(""split"", split($""input"", ""[|]""))

scala> withSplit.show
+---+-------------+----------------+
|num|        input|           split|
+---+-------------+----------------+
|  0|  hello|world|  [hello, world]|
|  1|witaj|swiecie|[witaj, swiecie]|
+---+-------------+----------------+
----

NOTE: `.$|()[{^?*+\\` are RegEx's meta characters and are considered special.

=== [[upper]] `upper` Function

[source, scala]
----
upper(e: Column): Column
----

`upper` function converts a string column into one with all letter upper. It returns a new `Column`.

NOTE: The following example uses two functions that accept a `Column` and return another to showcase how to chain them.

[source, scala]
----
val df = Seq((0,1,""hello""), (2,3,""world""), (2,4, ""ala"")).toDF(""id"", ""val"", ""name"")
val withUpperReversed = df.withColumn(""upper"", reverse(upper($""name"")))

scala> withUpperReversed.show
+---+---+-----+-----+
| id|val| name|upper|
+---+---+-----+-----+
|  0|  1|hello|OLLEH|
|  2|  3|world|DLROW|
|  2|  4|  ala|  ALA|
+---+---+-----+-----+
----

=== [[struct]] `struct` Functions

[source, scala]
----
struct(cols: Column*): Column
struct(colName: String, colNames: String*): Column
----

`struct` family of functions allows you to create a new struct column based on a collection of `Column` or their names.

NOTE: The difference between `struct` and another similar `array` function is that the types of the columns can be different (in `struct`).

[source, scala]
----
scala> df.withColumn(""struct"", struct($""name"", $""val"")).show
+---+---+-----+---------+
| id|val| name|   struct|
+---+---+-----+---------+
|  0|  1|hello|[hello,1]|
|  2|  3|world|[world,3]|
|  2|  4|  ala|  [ala,4]|
+---+---+-----+---------+
----

=== [[broadcast]] `broadcast` Function

[source, scala]
----
broadcast[T](df: Dataset[T]): Dataset[T]
----

`broadcast` function marks the input link:spark-sql-Dataset.adoc[Dataset] small enough to be used in broadcast `join`.

TIP: Read up on link:spark-sql-joins-broadcast.adoc[Broadcast Joins (aka Map-Side Joins)].

[source, scala]
----
val left = Seq((0, ""aa""), (0, ""bb"")).toDF(""id"", ""token"").as[(Int, String)]
val right = Seq((""aa"", 0.99), (""bb"", 0.57)).toDF(""token"", ""prob"").as[(String, Double)]

scala> left.join(broadcast(right), ""token"").explain(extended = true)
== Parsed Logical Plan ==
'Join UsingJoin(Inner,List(token))
:- Project [_1#123 AS id#126, _2#124 AS token#127]
:  +- LocalRelation [_1#123, _2#124]
+- BroadcastHint
   +- Project [_1#136 AS token#139, _2#137 AS prob#140]
      +- LocalRelation [_1#136, _2#137]

== Analyzed Logical Plan ==
token: string, id: int, prob: double
Project [token#127, id#126, prob#140]
+- Join Inner, (token#127 = token#139)
   :- Project [_1#123 AS id#126, _2#124 AS token#127]
   :  +- LocalRelation [_1#123, _2#124]
   +- BroadcastHint
      +- Project [_1#136 AS token#139, _2#137 AS prob#140]
         +- LocalRelation [_1#136, _2#137]

== Optimized Logical Plan ==
Project [token#127, id#126, prob#140]
+- Join Inner, (token#127 = token#139)
   :- Project [_1#123 AS id#126, _2#124 AS token#127]
   :  +- Filter isnotnull(_2#124)
   :     +- LocalRelation [_1#123, _2#124]
   +- BroadcastHint
      +- Project [_1#136 AS token#139, _2#137 AS prob#140]
         +- Filter isnotnull(_1#136)
            +- LocalRelation [_1#136, _2#137]

== Physical Plan ==
*Project [token#127, id#126, prob#140]
+- *BroadcastHashJoin [token#127], [token#139], Inner, BuildRight
   :- *Project [_1#123 AS id#126, _2#124 AS token#127]
   :  +- *Filter isnotnull(_2#124)
   :     +- LocalTableScan [_1#123, _2#124]
   +- BroadcastExchange HashedRelationBroadcastMode(List(input[0, string, true]))
      +- *Project [_1#136 AS token#139, _2#137 AS prob#140]
         +- *Filter isnotnull(_1#136)
            +- LocalTableScan [_1#136, _2#137]
----

=== [[expr]] `expr` Function

[source, scala]
----
expr(expr: String): Column
----

`expr` function parses the input `expr` SQL string to a `Column` it represents.

[source, scala]
----
val ds = Seq((0, ""hello""), (1, ""world""))
  .toDF(""id"", ""token"")
  .as[(Long, String)]

scala> ds.show
+---+-----+
| id|token|
+---+-----+
|  0|hello|
|  1|world|
+---+-----+

val filterExpr = expr(""token = 'hello'"")

scala> ds.filter(filterExpr).show
+---+-----+
| id|token|
+---+-----+
|  0|hello|
+---+-----+
----

Internally, `expr` uses the active session's link:spark-sql-SessionState.adoc[sqlParser] or creates a new  link:spark-sql-SparkSqlParser.adoc[SparkSqlParser] to call link:spark-sql-ParserInterface.adoc#parseExpression[parseExpression] method.

=== [[grouping]] `grouping` Aggregate Function

[source, scala]
----
grouping(e: Column): Column
grouping(columnName: String): Column  // <1>
----
<1> Calls the first `grouping` with `columnName` as a `Column`

`grouping` is an aggregate function that indicates whether a specified column is aggregated or not and:

* returns `1` if the column is in a subtotal and is `NULL`
* returns `0` if the underlying value is `NULL` or any other value

NOTE: `grouping` can only be used with link:spark-sql-multi-dimensional-aggregation.adoc#cube[cube], link:spark-sql-multi-dimensional-aggregation.adoc#rollup[rollup] or `GROUPING SETS` multi-dimensional aggregate operators (and is verified when link:spark-sql-Analyzer-CheckAnalysis.adoc#Grouping[`Analyzer` does check analysis]).

From https://cwiki.apache.org/confluence/display/Hive/Enhanced&#43;Aggregation%2C&#43;Cube%2C&#43;Grouping&#43;and&#43;Rollup#EnhancedAggregation,Cube,GroupingandRollup-Grouping\\_\\_IDfunction[Hive's documentation about Grouping__ID function] (that can somehow help to understand `grouping`):

> When aggregates are displayed for a column its value is `null`. This may conflict in case the column itself has some `null` values. There needs to be some way to identify `NULL` in column, which means aggregate and `NULL` in column, which means value. `GROUPING__ID` function is the solution to that.

[source, scala]
----
val tmpWorkshops = Seq(
  (""Warsaw"", 2016, 2),
  (""Toronto"", 2016, 4),
  (""Toronto"", 2017, 1)).toDF(""city"", ""year"", ""count"")

// there seems to be a bug with nulls
// and so the need for the following union
val cityNull = Seq(
  (null.asInstanceOf[String], 2016, 2)).toDF(""city"", ""year"", ""count"")

val workshops = tmpWorkshops union cityNull

scala> workshops.show
+-------+----+-----+
|   city|year|count|
+-------+----+-----+
| Warsaw|2016|    2|
|Toronto|2016|    4|
|Toronto|2017|    1|
|   null|2016|    2|
+-------+----+-----+

val q = workshops
  .cube(""city"", ""year"")
  .agg(grouping(""city""), grouping(""year"")) // <-- grouping here
  .sort($""city"".desc_nulls_last, $""year"".desc_nulls_last)

scala> q.show
+-------+----+--------------+--------------+
|   city|year|grouping(city)|grouping(year)|
+-------+----+--------------+--------------+
| Warsaw|2016|             0|             0|
| Warsaw|null|             0|             1|
|Toronto|2017|             0|             0|
|Toronto|2016|             0|             0|
|Toronto|null|             0|             1|
|   null|2017|             1|             0|
|   null|2016|             1|             0|
|   null|2016|             0|             0|  <-- null is city
|   null|null|             0|             1|  <-- null is city
|   null|null|             1|             1|
+-------+----+--------------+--------------+
----

Internally, `grouping` creates a link:spark-sql-Column.adoc[Column] with `Grouping` expression.

```
val q = workshops.cube(""city"", ""year"").agg(grouping(""city""))
scala> println(q.queryExecution.logical)
'Aggregate [cube(city#182, year#183)], [city#182, year#183, grouping('city) AS grouping(city)#705]
+- Union
   :- Project [_1#178 AS city#182, _2#179 AS year#183, _3#180 AS count#184]
   :  +- LocalRelation [_1#178, _2#179, _3#180]
   +- Project [_1#192 AS city#196, _2#193 AS year#197, _3#194 AS count#198]
      +- LocalRelation [_1#192, _2#193, _3#194]

scala> println(q.queryExecution.analyzed)
Aggregate [city#724, year#725, spark_grouping_id#721], [city#724, year#725, cast((shiftright(spark_grouping_id#721, 1) & 1) as tinyint) AS grouping(city)#720]
+- Expand [List(city#182, year#183, count#184, city#722, year#723, 0), List(city#182, year#183, count#184, city#722, null, 1), List(city#182, year#183, count#184, null, year#723, 2), List(city#182, year#183, count#184, null, null, 3)], [city#182, year#183, count#184, city#724, year#725, spark_grouping_id#721]
   +- Project [city#182, year#183, count#184, city#182 AS city#722, year#183 AS year#723]
      +- Union
         :- Project [_1#178 AS city#182, _2#179 AS year#183, _3#180 AS count#184]
         :  +- LocalRelation [_1#178, _2#179, _3#180]
         +- Project [_1#192 AS city#196, _2#193 AS year#197, _3#194 AS count#198]
            +- LocalRelation [_1#192, _2#193, _3#194]
```

NOTE: `grouping` was added to Spark SQL in https://issues.apache.org/jira/browse/SPARK-12706[[SPARK-12706\\] support grouping/grouping_id function together group set].

=== [[grouping_id]] `grouping_id` Aggregate Function

[source, scala]
----
grouping_id(cols: Column*): Column
grouping_id(colName: String, colNames: String*): Column // <1>
----
<1> Calls the first `grouping_id` with `colName` and `colNames` as objects of type `Column`

`grouping_id` is an aggregate function that computes the level of grouping:

* `0` for combinations of each column
* `1` for subtotals of column 1
* `2` for subtotals of column 2
* And so on&hellip;

[source, scala]
----
val tmpWorkshops = Seq(
  (""Warsaw"", 2016, 2),
  (""Toronto"", 2016, 4),
  (""Toronto"", 2017, 1)).toDF(""city"", ""year"", ""count"")

// there seems to be a bug with nulls
// and so the need for the following union
val cityNull = Seq(
  (null.asInstanceOf[String], 2016, 2)).toDF(""city"", ""year"", ""count"")

val workshops = tmpWorkshops union cityNull

scala> workshops.show
+-------+----+-----+
|   city|year|count|
+-------+----+-----+
| Warsaw|2016|    2|
|Toronto|2016|    4|
|Toronto|2017|    1|
|   null|2016|    2|
+-------+----+-----+

val query = workshops
  .cube(""city"", ""year"")
  .agg(grouping_id()) // <-- all grouping columns used
  .sort($""city"".desc_nulls_last, $""year"".desc_nulls_last)
scala> query.show
+-------+----+-------------+
|   city|year|grouping_id()|
+-------+----+-------------+
| Warsaw|2016|            0|
| Warsaw|null|            1|
|Toronto|2017|            0|
|Toronto|2016|            0|
|Toronto|null|            1|
|   null|2017|            2|
|   null|2016|            2|
|   null|2016|            0|
|   null|null|            1|
|   null|null|            3|
+-------+----+-------------+

scala> spark.catalog.listFunctions.filter(_.name.contains(""grouping_id"")).show(false)
+-----------+--------+-----------+----------------------------------------------------+-----------+
|name       |database|description|className                                           |isTemporary|
+-----------+--------+-----------+----------------------------------------------------+-----------+
|grouping_id|null    |null       |org.apache.spark.sql.catalyst.expressions.GroupingID|true       |
+-----------+--------+-----------+----------------------------------------------------+-----------+

// bin function gives the string representation of the binary value of the given long column
scala> query.withColumn(""bitmask"", bin($""grouping_id()"")).show
+-------+----+-------------+-------+
|   city|year|grouping_id()|bitmask|
+-------+----+-------------+-------+
| Warsaw|2016|            0|      0|
| Warsaw|null|            1|      1|
|Toronto|2017|            0|      0|
|Toronto|2016|            0|      0|
|Toronto|null|            1|      1|
|   null|2017|            2|     10|
|   null|2016|            2|     10|
|   null|2016|            0|      0|  <-- null is city
|   null|null|            3|     11|
|   null|null|            1|      1|
+-------+----+-------------+-------+
----

The list of columns of `grouping_id` should match grouping columns (in `cube` or `rollup`) exactly, or empty which means all the grouping columns (which is exactly what the function expects).

NOTE: `grouping_id` can only be used with link:spark-sql-multi-dimensional-aggregation.adoc#cube[cube], link:spark-sql-multi-dimensional-aggregation.adoc#rollup[rollup] or `GROUPING SETS` multi-dimensional aggregate operators (and is verified when link:spark-sql-Analyzer-CheckAnalysis.adoc#GroupingID[`Analyzer` does check analysis]).

NOTE: Spark SQL's `grouping_id` function is known as `grouping__id` in Hive.

From https://cwiki.apache.org/confluence/display/Hive/Enhanced&#43;Aggregation%2C&#43;Cube%2C&#43;Grouping&#43;and&#43;Rollup#EnhancedAggregation,Cube,GroupingandRollup-Grouping\\_\\_IDfunction[Hive's documentation about Grouping__ID function]:

> When aggregates are displayed for a column its value is `null`. This may conflict in case the column itself has some `null` values. There needs to be some way to identify `NULL` in column, which means aggregate and `NULL` in column, which means value. `GROUPING__ID` function is the solution to that.

Internally, `grouping_id()` creates a link:spark-sql-Column.adoc[Column] with `GroupingID` unevaluable expression.

NOTE: link:spark-sql-Expression.adoc#Unevaluable[Unevaluable expressions] are expressions replaced by some other expressions during link:spark-sql-Analyzer.adoc[analysis] or link:spark-sql-Optimizer.adoc[optimization].

```
// workshops dataset was defined earlier
val q = workshops
  .cube(""city"", ""year"")
  .agg(grouping_id())

// grouping_id function is spark_grouping_id virtual column internally
// that is resolved during analysis - see Analyzed Logical Plan
scala> q.explain(true)
== Parsed Logical Plan ==
'Aggregate [cube(city#182, year#183)], [city#182, year#183, grouping_id() AS grouping_id()#742]
+- Union
   :- Project [_1#178 AS city#182, _2#179 AS year#183, _3#180 AS count#184]
   :  +- LocalRelation [_1#178, _2#179, _3#180]
   +- Project [_1#192 AS city#196, _2#193 AS year#197, _3#194 AS count#198]
      +- LocalRelation [_1#192, _2#193, _3#194]

== Analyzed Logical Plan ==
city: string, year: int, grouping_id(): int
Aggregate [city#757, year#758, spark_grouping_id#754], [city#757, year#758, spark_grouping_id#754 AS grouping_id()#742]
+- Expand [List(city#182, year#183, count#184, city#755, year#756, 0), List(city#182, year#183, count#184, city#755, null, 1), List(city#182, year#183, count#184, null, year#756, 2), List(city#182, year#183, count#184, null, null, 3)], [city#182, year#183, count#184, city#757, year#758, spark_grouping_id#754]
   +- Project [city#182, year#183, count#184, city#182 AS city#755, year#183 AS year#756]
      +- Union
         :- Project [_1#178 AS city#182, _2#179 AS year#183, _3#180 AS count#184]
         :  +- LocalRelation [_1#178, _2#179, _3#180]
         +- Project [_1#192 AS city#196, _2#193 AS year#197, _3#194 AS count#198]
            +- LocalRelation [_1#192, _2#193, _3#194]

== Optimized Logical Plan ==
Aggregate [city#757, year#758, spark_grouping_id#754], [city#757, year#758, spark_grouping_id#754 AS grouping_id()#742]
+- Expand [List(city#755, year#756, 0), List(city#755, null, 1), List(null, year#756, 2), List(null, null, 3)], [city#757, year#758, spark_grouping_id#754]
   +- Union
      :- LocalRelation [city#755, year#756]
      +- LocalRelation [city#755, year#756]

== Physical Plan ==
*HashAggregate(keys=[city#757, year#758, spark_grouping_id#754], functions=[], output=[city#757, year#758, grouping_id()#742])
+- Exchange hashpartitioning(city#757, year#758, spark_grouping_id#754, 200)
   +- *HashAggregate(keys=[city#757, year#758, spark_grouping_id#754], functions=[], output=[city#757, year#758, spark_grouping_id#754])
      +- *Expand [List(city#755, year#756, 0), List(city#755, null, 1), List(null, year#756, 2), List(null, null, 3)], [city#757, year#758, spark_grouping_id#754]
         +- Union
            :- LocalTableScan [city#755, year#756]
            +- LocalTableScan [city#755, year#756]
```

NOTE: `grouping_id` was added to Spark SQL in https://issues.apache.org/jira/browse/SPARK-12706[[SPARK-12706\\] support grouping/grouping_id function together group set].

=== [[from_json]] Parsing Column With JSON-Encoded Records -- `from_json` Functions

[source, scala]
----
from_json(e: Column, schema: DataType): Column  // <1>
from_json(
  e: Column,
  schema: DataType,
  options: Map[String, String]): Column
----
<1> Relays to the other `from_json` with empty `options`

Parses a column with a JSON string into a link:spark-sql-StructType.adoc[StructType] or link:spark-sql-DataType.adoc#ArrayType[ArrayType] of `StructType` elements with the specified schema.

NOTE: `options` controls how a JSON is parsed and contains the same options as the link:spark-sql-JsonDataSource.adoc[json data source].

Internally, `from_json` creates a link:spark-sql-Column.adoc[Column] with link:spark-sql-Expression-JsonToStructs.adoc[JsonToStructs] unary expression.

[source, scala]
----
val jsons = Seq(""""""{ ""id"": 0 }"""""").toDF(""json"")

import org.apache.spark.sql.types._
val schema = StructType(
  StructField(""id"", IntegerType, nullable = false) :: Nil)

scala> jsons.select(from_json($""json"", schema) as ""ids"").show
+---+
|ids|
+---+
|[0]|
+---+
----

NOTE: `from_json` corresponds to SQL's `from_json`.

=== [[bin]] Converting Long to Binary Format (in String Representation) -- `bin` Function

[source, scala]
----
bin(e: Column): Column
bin(columnName: String): Column // <1>
----
<1> Calls the first `bin` with `columnName` as a `Column`

`bin` converts the long value in a column to its binary format (i.e. as an unsigned integer in base 2) with no extra leading 0s.

[source, scala]
----
scala> spark.range(5).withColumn(""binary"", bin('id)).show
+---+------+
| id|binary|
+---+------+
|  0|     0|
|  1|     1|
|  2|    10|
|  3|    11|
|  4|   100|
+---+------+

val withBin = spark.range(5).withColumn(""binary"", bin('id))
scala> withBin.printSchema
root
 |-- id: long (nullable = false)
 |-- binary: string (nullable = false)
----

Internally, `bin` creates a link:spark-sql-Column.adoc[Column] with `Bin` unary expression.

[source, scala]
----
scala> withBin.queryExecution.logical
res2: org.apache.spark.sql.catalyst.plans.logical.LogicalPlan =
'Project [*, bin('id) AS binary#14]
+- Range (0, 5, step=1, splits=Some(8))
----

NOTE: `Bin` unary expression uses link:++https://docs.oracle.com/javase/8/docs/api/java/lang/Long.html#toBinaryString-long-++[java.lang.Long.toBinaryString] for the conversion.

[NOTE]
====
`Bin` expression supports link:spark-sql-Expression.adoc#doGenCode[code generation] (aka _CodeGen_).

```
val withBin = spark.range(5).withColumn(""binary"", bin('id))
scala> withBin.queryExecution.debug.codegen
Found 1 WholeStageCodegen subtrees.
== Subtree 1 / 1 ==
*Project [id#19L, bin(id#19L) AS binary#22]
+- *Range (0, 5, step=1, splits=Some(8))
...
/* 103 */           UTF8String project_value1 = null;
/* 104 */           project_value1 = UTF8String.fromString(java.lang.Long.toBinaryString(range_value));

```
====
",12033,False,2161.919066309521,median
"/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkPolyData.cxx

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#include ""vtkPolyData.h""

#include ""vtkCellArray.h""
#include ""vtkCellData.h""
#include ""vtkCriticalSection.h""
#include ""vtkEmptyCell.h""
#include ""vtkGenericCell.h""
#include ""vtkInformation.h""
#include ""vtkInformationVector.h""
#include ""vtkLine.h""
#include ""vtkNew.h""
#include ""vtkObjectFactory.h""
#include ""vtkPointData.h""
#include ""vtkPointLocator.h""
#include ""vtkPolyLine.h""
#include ""vtkPolyVertex.h""
#include ""vtkPolygon.h""
#include ""vtkQuad.h""
#include ""vtkTriangle.h""
#include ""vtkTriangleStrip.h""
#include ""vtkVertex.h""

#include ""vtkSmartPointer.h""

vtkStandardNewMacro(vtkPolyData);

//----------------------------------------------------------------------------
// Initialize static member.  This member is used to simplify traversal
// of verts, lines, polygons, and triangle strips lists.  It basically
// ""marks"" empty lists so that the traveral method ""GetNextCell""
// works properly.

struct vtkPolyDataDummyContainter
{
  vtkSmartPointer<vtkCellArray> Dummy;

  vtkPolyDataDummyContainter()
    {
      this->Dummy.TakeReference(vtkCellArray::New());
    }
};

vtkPolyDataDummyContainter vtkPolyData::DummyContainer;

vtkPolyData::vtkPolyData () :
  Vertex(NULL), PolyVertex(NULL), Line(NULL), PolyLine(NULL),
  Triangle(NULL), Quad(NULL), Polygon(NULL), TriangleStrip(NULL),
  EmptyCell(NULL), Verts(NULL), Lines(NULL), Polys(NULL),
  Strips(NULL), Cells(NULL), Links(NULL)
{
  this->Information->Set(vtkDataObject::DATA_EXTENT_TYPE(), VTK_PIECES_EXTENT);
  this->Information->Set(vtkDataObject::DATA_PIECE_NUMBER(), -1);
  this->Information->Set(vtkDataObject::DATA_NUMBER_OF_PIECES(), 1);
  this->Information->Set(vtkDataObject::DATA_NUMBER_OF_GHOST_LEVELS(), 0);
}

//----------------------------------------------------------------------------
vtkPolyData::~vtkPolyData()
{
  this->Cleanup();

  if (this->Vertex)
    {
    this->Vertex->Delete();
    }

  if (this->PolyVertex)
    {
    this->PolyVertex->Delete();
    }

  if (this->Line)
    {
    this->Line->Delete();
    }

  if (this->PolyLine)
    {
    this->PolyLine->Delete();
    }

  if (this->Triangle)
    {
    this->Triangle->Delete();
    }

  if (this->Quad)
    {
    this->Quad->Delete();
    }

  if (this->Polygon)
    {
    this->Polygon->Delete();
    }

  if (this->TriangleStrip)
    {
    this->TriangleStrip->Delete();
    }

  if (this->EmptyCell)
    {
    this->EmptyCell->Delete();
    }
}

//----------------------------------------------------------------------------
int vtkPolyData::GetPiece()
{
  return this->Information->Get(vtkDataObject::DATA_PIECE_NUMBER());
}

//----------------------------------------------------------------------------
int vtkPolyData::GetNumberOfPieces()
{
  return this->Information->Get(vtkDataObject::DATA_NUMBER_OF_PIECES());
}

//----------------------------------------------------------------------------
int vtkPolyData::GetGhostLevel()
{
  return this->Information->Get(vtkDataObject::DATA_NUMBER_OF_GHOST_LEVELS());
}

//----------------------------------------------------------------------------
// Copy the geometric and topological structure of an input poly data object.
void vtkPolyData::CopyStructure(vtkDataSet *ds)
{
  vtkPolyData *pd=static_cast<vtkPolyData *>(ds);
  vtkPointSet::CopyStructure(ds);

  if (this->Verts != pd->Verts)
    {
    if (this->Verts)
      {
      this->Verts->UnRegister(this);
      }
    this->Verts = pd->Verts;
    if (this->Verts)
      {
      this->Verts->Register(this);
      }
    }

  if (this->Lines != pd->Lines)
    {
    if (this->Lines)
      {
      this->Lines->UnRegister(this);
      }
    this->Lines = pd->Lines;
    if (this->Lines)
      {
      this->Lines->Register(this);
      }
    }

  if (this->Polys != pd->Polys)
    {
    if (this->Polys)
      {
      this->Polys->UnRegister(this);
      }
    this->Polys = pd->Polys;
    if (this->Polys)
      {
      this->Polys->Register(this);
      }
    }

  if (this->Strips != pd->Strips)
    {
    if (this->Strips)
      {
      this->Strips->UnRegister(this);
      }
    this->Strips = pd->Strips;
    if (this->Strips)
      {
      this->Strips->Register(this);
      }
    }

  if ( this->Cells )
    {
    this->Cells->UnRegister(this);
    this->Cells = NULL;
    }

  if ( this->Links )
    {
    this->Links->UnRegister(this);
    this->Links = NULL;
    }
}

//----------------------------------------------------------------------------
int vtkPolyData::GetCellType(vtkIdType cellId)
{
  if ( !this->Cells )
    {
    this->BuildCells();
    }
  return this->Cells->GetCellType(cellId);
}

//----------------------------------------------------------------------------
vtkCell *vtkPolyData::GetCell(vtkIdType cellId)
{
  int i, loc;
  vtkIdType *pts, numPts;
  vtkCell *cell = NULL;
  unsigned char type;

  if ( !this->Cells )
    {
    this->BuildCells();
    }

  type = this->Cells->GetCellType(cellId);
  loc = this->Cells->GetCellLocation(cellId);

  switch (type)
    {
    case VTK_VERTEX:
      if (!this->Vertex)
        {
        this->Vertex = vtkVertex::New();
        }
      cell = this->Vertex;
      this->Verts->GetCell(loc,numPts,pts);
      break;

    case VTK_POLY_VERTEX:
      if (! this->PolyVertex)
        {
        this->PolyVertex = vtkPolyVertex::New();
        }
      cell = this->PolyVertex;
      this->Verts->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    case VTK_LINE:
      if (! this->Line )
        {
        this->Line = vtkLine::New();
        }
      cell = this->Line;
      this->Lines->GetCell(loc,numPts,pts);
      break;

    case VTK_POLY_LINE:
      if (!this->PolyLine)
        {
        this->PolyLine = vtkPolyLine::New();
        }
      cell = this->PolyLine;
      this->Lines->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    case VTK_TRIANGLE:
      if (!this->Triangle)
        {
        this->Triangle = vtkTriangle::New();
        }
      cell = this->Triangle;
      this->Polys->GetCell(loc,numPts,pts);
      break;

    case VTK_QUAD:
      if (!this->Quad)
        {
        this->Quad = vtkQuad::New();
        }
      cell = this->Quad;
      this->Polys->GetCell(loc,numPts,pts);
      break;

    case VTK_POLYGON:
      if (!this->Polygon)
        {
        this->Polygon = vtkPolygon::New();
        }
      cell = this->Polygon;
      this->Polys->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    case VTK_TRIANGLE_STRIP:
      if (!this->TriangleStrip)
        {
        this->TriangleStrip = vtkTriangleStrip::New();
        }
      cell = this->TriangleStrip;
      this->Strips->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    default:
      if (!this->EmptyCell)
        {
        this->EmptyCell = vtkEmptyCell::New();
        }
      cell = this->EmptyCell;
      return cell;
    }

  for (i=0; i < numPts; i++)
    {
    cell->PointIds->SetId(i,pts[i]);
    cell->Points->SetPoint(i,this->Points->GetPoint(pts[i]));
    }

  return cell;
}

//----------------------------------------------------------------------------
void vtkPolyData::GetCell(vtkIdType cellId, vtkGenericCell *cell)
{
  int             i, loc;
  vtkIdType       *pts=0;
  vtkIdType       numPts;
  unsigned char   type;
  double           x[3];

  if ( !this->Cells )
    {
    this->BuildCells();
    }

  type = this->Cells->GetCellType(cellId);
  loc = this->Cells->GetCellLocation(cellId);

  switch (type)
    {
    case VTK_VERTEX:
      cell->SetCellTypeToVertex();
      this->Verts->GetCell(loc,numPts,pts);
      break;

    case VTK_POLY_VERTEX:
      cell->SetCellTypeToPolyVertex();
      this->Verts->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    case VTK_LINE:
      cell->SetCellTypeToLine();
      this->Lines->GetCell(loc,numPts,pts);
      break;

    case VTK_POLY_LINE:
      cell->SetCellTypeToPolyLine();
      this->Lines->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    case VTK_TRIANGLE:
      cell->SetCellTypeToTriangle();
      this->Polys->GetCell(loc,numPts,pts);
      break;

    case VTK_QUAD:
      cell->SetCellTypeToQuad();
      this->Polys->GetCell(loc,numPts,pts);
      break;

    case VTK_POLYGON:
      cell->SetCellTypeToPolygon();
      this->Polys->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    case VTK_TRIANGLE_STRIP:
      cell->SetCellTypeToTriangleStrip();
      this->Strips->GetCell(loc,numPts,pts);
      cell->PointIds->SetNumberOfIds(numPts); //reset number of points
      cell->Points->SetNumberOfPoints(numPts);
      break;

    default:
      cell->SetCellTypeToEmptyCell();
      numPts = 0;
    }

  for (i=0; i < numPts; i++)
    {
    cell->PointIds->SetId(i,pts[i]);
    this->Points->GetPoint(pts[i], x);
    cell->Points->SetPoint(i, x);
    }
}

//----------------------------------------------------------------------------
void vtkPolyData::CopyCells(vtkPolyData *pd, vtkIdList *idList,
                            vtkPointLocator *locator)
{
  vtkIdType cellId, ptId, newId, newCellId, locatorPtId;
  int numPts, numCellPts, i;
  vtkPoints *newPoints;
  vtkIdList *pointMap = vtkIdList::New(); //maps old pt ids into new
  vtkIdList *cellPts, *newCellPts = vtkIdList::New();
  vtkGenericCell *cell = vtkGenericCell::New();
  double x[3];
  vtkPointData *outPD = this->GetPointData();
  vtkCellData *outCD = this->GetCellData();

  numPts = pd->GetNumberOfPoints();

  if (this->GetPoints() == NULL)
    {
    this->Points = vtkPoints::New();
    }

  newPoints = this->GetPoints();

  pointMap->SetNumberOfIds(numPts);
  for (i=0; i < numPts; i++)
    {
    pointMap->SetId(i,-1);
    }

  // Filter the cells
  for (cellId=0; cellId < idList->GetNumberOfIds(); cellId++)
    {
    pd->GetCell(idList->GetId(cellId), cell);
    cellPts = cell->GetPointIds();
    numCellPts = cell->GetNumberOfPoints();

    for (i=0; i < numCellPts; i++)
      {
      ptId = cellPts->GetId(i);
      if ( (newId = pointMap->GetId(ptId)) < 0 )
        {
        pd->GetPoint(ptId, x);
        if (locator != NULL)
          {
          if ((locatorPtId = locator->IsInsertedPoint(x)) == -1)
            {
            newId = newPoints->InsertNextPoint(x);
            locator->InsertNextPoint(x);
            pointMap->SetId(ptId, newId);
            outPD->CopyData(pd->GetPointData(), ptId, newId);
            }
          else
            {
            newId = locatorPtId;
            }
          }
        else
          {
          newId = newPoints->InsertNextPoint(x);
          pointMap->SetId(ptId, newId);
          outPD->CopyData(pd->GetPointData(), ptId, newId);
          }
        }
      newCellPts->InsertId(i,newId);
      }
    newCellId = this->InsertNextCell(cell->GetCellType(), newCellPts);
    outCD->CopyData(pd->GetCellData(), idList->GetId(cellId), newCellId);
    newCellPts->Reset();
    } // for all cells
  newCellPts->Delete();
  pointMap->Delete();
  cell->Delete();
}

//----------------------------------------------------------------------------
// Fast implementation of GetCellBounds().  Bounds are calculated without
// constructing a cell.
void vtkPolyData::GetCellBounds(vtkIdType cellId, double bounds[6])
{
  int i, loc;
  vtkIdType *pts, numPts;
  unsigned char type;
  double x[3];

  if ( !this->Cells )
    {
    this->BuildCells();
    }

  type = this->Cells->GetCellType(cellId);
  loc = this->Cells->GetCellLocation(cellId);

  switch (type)
    {
    case VTK_VERTEX:
    case VTK_POLY_VERTEX:
      this->Verts->GetCell(loc,numPts,pts);
      break;

    case VTK_LINE:
    case VTK_POLY_LINE:
      this->Lines->GetCell(loc,numPts,pts);
      break;

    case VTK_TRIANGLE:
    case VTK_QUAD:
    case VTK_POLYGON:
      this->Polys->GetCell(loc,numPts,pts);
      break;

    case VTK_TRIANGLE_STRIP:
      this->Strips->GetCell(loc,numPts,pts);
      break;

    default:
      bounds[0] = bounds[1] = bounds[2] = bounds[3] = bounds[4] = bounds[5]
        = 0.0;
      return;
    }

  // carefully compute the bounds
  if (numPts)
    {
    this->Points->GetPoint( pts[0], x );
    bounds[0] = x[0];
    bounds[2] = x[1];
    bounds[4] = x[2];
    bounds[1] = x[0];
    bounds[3] = x[1];
    bounds[5] = x[2];
    for (i=1; i < numPts; i++)
      {
      this->Points->GetPoint( pts[i], x );
      bounds[0] = (x[0] < bounds[0] ? x[0] : bounds[0]);
      bounds[1] = (x[0] > bounds[1] ? x[0] : bounds[1]);
      bounds[2] = (x[1] < bounds[2] ? x[1] : bounds[2]);
      bounds[3] = (x[1] > bounds[3] ? x[1] : bounds[3]);
      bounds[4] = (x[2] < bounds[4] ? x[2] : bounds[4]);
      bounds[5] = (x[2] > bounds[5] ? x[2] : bounds[5]);
      }
    }
  else
    {
    vtkMath::UninitializeBounds(bounds);
    }
}


//----------------------------------------------------------------------------
void vtkPolyData::ComputeBounds()
{
  if (this->GetMTime() > this->ComputeTime)
    {
    // If there are no cells, but there are points, back to the
    // bounds of the points set.
    if (this->GetNumberOfCells() == 0 && this->GetNumberOfPoints())
      {
      vtkPointSet::ComputeBounds();
      return;
      }

    int t, i;
    vtkIdType *pts = 0;
    vtkIdType npts = 0;
    double x[3];

    vtkCellArray *cella[4];

    cella[0] = this->GetVerts();
    cella[1] = this->GetLines();
    cella[2] = this->GetPolys();
    cella[3] = this->GetStrips();

    // carefully compute the bounds
    int doneOne = 0;
    this->Bounds[0] = this->Bounds[2] = this->Bounds[4] =  VTK_DOUBLE_MAX;
    this->Bounds[1] = this->Bounds[3] = this->Bounds[5] = -VTK_DOUBLE_MAX;

    // Iterate over cells's points
    for (t = 0; t < 4; t++)
      {
      for (cella[t]->InitTraversal(); cella[t]->GetNextCell(npts,pts); )
        {
        for (i = 0;  i < npts; i++)
          {
          this->Points->GetPoint( pts[i], x );
          this->Bounds[0] = (x[0] < this->Bounds[0] ? x[0] : this->Bounds[0]);
          this->Bounds[1] = (x[0] > this->Bounds[1] ? x[0] : this->Bounds[1]);
          this->Bounds[2] = (x[1] < this->Bounds[2] ? x[1] : this->Bounds[2]);
          this->Bounds[3] = (x[1] > this->Bounds[3] ? x[1] : this->Bounds[3]);
          this->Bounds[4] = (x[2] < this->Bounds[4] ? x[2] : this->Bounds[4]);
          this->Bounds[5] = (x[2] > this->Bounds[5] ? x[2] : this->Bounds[5]);
          doneOne = 1;
          }
        }
      }
    if (!doneOne)
      {
      vtkMath::UninitializeBounds(this->Bounds);
      }
    this->ComputeTime.Modified();
    }
}

//----------------------------------------------------------------------------
// Set the cell array defining vertices.
void vtkPolyData::SetVerts (vtkCellArray* v)
{
  if (v == this->DummyContainer.Dummy.GetPointer())
    {
    v = NULL;
    }
  if ( v != this->Verts)
    {
    if (this->Verts)
      {
      this->Verts->UnRegister(this);
      }
    this->Verts = v;
    if (this->Verts)
      {
      this->Verts->Register(this);
      }
    this->Modified();
    }
}

//----------------------------------------------------------------------------
// Get the cell array defining vertices. If there are no vertices, an
// empty array will be returned (convenience to simplify traversal).
vtkCellArray* vtkPolyData::GetVerts()
{
  if ( !this->Verts )
    {
    return this->DummyContainer.Dummy.GetPointer();
    }
  else
    {
    return this->Verts;
    }
}

//----------------------------------------------------------------------------
// Set the cell array defining lines.
void vtkPolyData::SetLines (vtkCellArray* l)
{
  if (l == this->DummyContainer.Dummy.GetPointer())
    {
    l = NULL;
    }
  if ( l != this->Lines)
    {
    if (this->Lines)
      {
      this->Lines->UnRegister(this);
      }
    this->Lines = l;
    if (this->Lines)
      {
      this->Lines->Register(this);
      }
    this->Modified();
    }
}

//----------------------------------------------------------------------------
// Get the cell array defining lines. If there are no lines, an
// empty array will be returned (convenience to simplify traversal).
vtkCellArray* vtkPolyData::GetLines()
{
  if ( !this->Lines )
    {
    return this->DummyContainer.Dummy.GetPointer();
    }
  else
    {
    return this->Lines;
    }
}

//----------------------------------------------------------------------------
// Set the cell array defining polygons.
void vtkPolyData::SetPolys (vtkCellArray* p)
{
  if(p == this->DummyContainer.Dummy.GetPointer())
    {
    p = NULL;
    }
  if ( p != this->Polys)
    {
    if (this->Polys)
      {
      this->Polys->UnRegister(this);
      }
    this->Polys = p;
    if (this->Polys)
      {
      this->Polys->Register(this);
      }
    this->Modified();
    }
}

//----------------------------------------------------------------------------
// Get the cell array defining polygons. If there are no polygons, an
// empty array will be returned (convenience to simplify traversal).
vtkCellArray* vtkPolyData::GetPolys()
{
  if ( !this->Polys )
    {
    return this->DummyContainer.Dummy.GetPointer();
    }
  else
    {
    return this->Polys;
    }
}

//----------------------------------------------------------------------------
// Set the cell array defining triangle strips.
void vtkPolyData::SetStrips (vtkCellArray* s)
{
  if ( s == this->DummyContainer.Dummy.GetPointer())
    {
    s = NULL;
    }
  if ( s != this->Strips)
    {
    if (this->Strips)
      {
      this->Strips->UnRegister(this);
      }
    this->Strips = s;
    if (this->Strips)
      {
      this->Strips->Register(this);
      }
    this->Modified();
    }
}

//----------------------------------------------------------------------------
// Get the cell array defining triangle strips. If there are no
// triangle strips, an empty array will be returned (convenience to
// simplify traversal).
vtkCellArray* vtkPolyData::GetStrips()
{
  if ( !this->Strips )
    {
    return this->DummyContainer.Dummy.GetPointer();
    }
  else
    {
    return this->Strips;
    }
}

//----------------------------------------------------------------------------
void vtkPolyData::Cleanup()
{
  if ( this->Verts )
    {
    this->Verts->UnRegister(this);
    this->Verts = NULL;
    }

  if ( this->Lines )
    {
    this->Lines->UnRegister(this);
    this->Lines = NULL;
    }

  if ( this->Polys )
    {
    this->Polys->UnRegister(this);
    this->Polys = NULL;
    }

  if ( this->Strips )
    {
    this->Strips->UnRegister(this);
    this->Strips = NULL;
    }

  if ( this->Cells )
    {
    this->Cells->UnRegister(this);
    this->Cells = NULL;
    }

  if ( this->Links )
    {
    this->Links->UnRegister(this);
    this->Links = NULL;
    }
}

//----------------------------------------------------------------------------
// Restore object to initial state. Release memory back to system.
void vtkPolyData::Initialize()
{
  vtkPointSet::Initialize();

  this->Cleanup();

  if(this->Information)
    {
    this->Information->Set(vtkDataObject::DATA_PIECE_NUMBER(), -1);
    this->Information->Set(vtkDataObject::DATA_NUMBER_OF_PIECES(), 0);
    this->Information->Set(vtkDataObject::DATA_NUMBER_OF_GHOST_LEVELS(), 0);
    }
}

//----------------------------------------------------------------------------
int vtkPolyData::GetMaxCellSize()
{
  int maxCellSize=0, cellSize;

  if ( this->Verts )
    {
    cellSize = this->Verts->GetMaxCellSize();
    if ( cellSize > maxCellSize )
      {
      maxCellSize = cellSize;
      }
    }

  if ( this->Lines )
    {
    cellSize = this->Lines->GetMaxCellSize();
    if ( cellSize > maxCellSize )
      {
      maxCellSize = cellSize;
      }
    }

  if ( this->Polys )
    {
    cellSize = this->Polys->GetMaxCellSize();
    if ( cellSize > maxCellSize )
      {
      maxCellSize = cellSize;
      }
    }

  if ( this->Strips )
    {
    cellSize = this->Strips->GetMaxCellSize();
    if ( cellSize > maxCellSize )
      {
      maxCellSize = cellSize;
      }
    }

  return maxCellSize;
}

//----------------------------------------------------------------------------
vtkIdType vtkPolyData::GetNumberOfCells()
{
  return this->GetNumberOfVerts() + this->GetNumberOfLines() +
         this->GetNumberOfPolys() + this->GetNumberOfStrips();
}

//----------------------------------------------------------------------------
vtkIdType vtkPolyData::GetNumberOfVerts()
{
  return (this->Verts ? this->Verts->GetNumberOfCells() : 0);
}

vtkIdType vtkPolyData::GetNumberOfLines()
{
  return (this->Lines ? this->Lines->GetNumberOfCells() : 0);
}

vtkIdType vtkPolyData::GetNumberOfPolys()
{
  return (this->Polys ? this->Polys->GetNumberOfCells() : 0);
}

vtkIdType vtkPolyData::GetNumberOfStrips()
{
  return (this->Strips ? this->Strips->GetNumberOfCells() : 0);
}


//----------------------------------------------------------------------------
void vtkPolyData::DeleteCells()
{
  // if we have Links, we need to delete them (they are no longer valid)
  if (this->Links)
    {
    this->Links->UnRegister( this );
    this->Links = NULL;
    }

  if (this->Cells)
    {
    this->Cells->UnRegister( this );
    this->Cells = NULL;
    }
}

//----------------------------------------------------------------------------
// Create data structure that allows random access of cells.
void vtkPolyData::BuildCells()
{
  if (this->Cells)
    {
    this->DeleteCells();
    }

  vtkCellArray *vertCells = this->GetVerts();
  vtkCellArray *lineCells = this->GetLines();
  vtkCellArray *polyCells = this->GetPolys();
  vtkCellArray *stripCells = this->GetStrips();

  // here are the number of cells we have
  vtkIdType nVerts = vertCells->GetNumberOfCells();
  vtkIdType nLines = lineCells->GetNumberOfCells();
  vtkIdType nPolys = polyCells->GetNumberOfCells();
  vtkIdType nStrips = stripCells->GetNumberOfCells();

  // pre-allocate the space we need
  vtkIdType nCells = nVerts + nLines + nPolys + nStrips;

  vtkUnsignedCharArray *types = vtkUnsignedCharArray::New();
  unsigned char *pTypes = types->WritePointer(0, nCells);

  vtkIntArray *locs = vtkIntArray::New();
  int *pLocs = locs->WritePointer(0, nCells);

  // record locations and type of each cell.
  // verts
  vtkIdType numCellPts;
  vtkIdType nextCellPts;
  if (nVerts)
    {
    vtkIdType *pVerts = vertCells->GetData()->GetPointer(0);
    numCellPts = pVerts[0];
    nextCellPts = numCellPts + 1;
    pLocs[0] = 0;
    pTypes[0] = numCellPts > 1 ? VTK_POLY_VERTEX : VTK_VERTEX;
    for (vtkIdType i = 1; i < nVerts; ++i)
      {
      numCellPts = pVerts[nextCellPts];
      pLocs[i] = nextCellPts;
      pTypes[i] = numCellPts > 1 ? VTK_POLY_VERTEX : VTK_VERTEX;
      nextCellPts += numCellPts + 1;
      }
    pLocs += nVerts;
    pTypes += nVerts;
    }

  // lines
  if (nLines)
    {
    vtkIdType *pLines = lineCells->GetData()->GetPointer(0);
    numCellPts = pLines[0];
    pLocs[0] = 0;
    pTypes[0] = numCellPts > 2 ? VTK_POLY_LINE : VTK_LINE;
    nextCellPts = numCellPts + 1;
    for (vtkIdType i = 1; i < nLines; ++i)
      {
      numCellPts = pLines[nextCellPts];
      pLocs[i] = nextCellPts;
      pTypes[i] = numCellPts > 2 ? VTK_POLY_LINE : VTK_LINE;
      nextCellPts += numCellPts + 1;
      }
    pLocs += nLines;
    pTypes += nLines;
    }

  // polys
  if (nPolys)
    {
    vtkIdType *pPolys = polyCells->GetData()->GetPointer(0);
    numCellPts = pPolys[0];
    pLocs[0] = 0;
    pTypes[0] = numCellPts == 3 ? VTK_TRIANGLE :
      numCellPts == 4 ? VTK_QUAD : VTK_POLYGON;
    nextCellPts = numCellPts + 1;
    for (vtkIdType i = 1; i < nPolys; ++i)
      {
      numCellPts = pPolys[nextCellPts];
      pLocs[i] = nextCellPts;
      pTypes[i] = numCellPts == 3 ? VTK_TRIANGLE :
        numCellPts == 4 ? VTK_QUAD : VTK_POLYGON;
      nextCellPts += numCellPts + 1;
      }
    pLocs += nPolys;
    pTypes += nPolys;
    }

  // strips
  if (nStrips)
    {
    std::fill_n(pTypes, nStrips, VTK_TRIANGLE_STRIP);
    vtkIdType *pStrips = stripCells->GetData()->GetPointer(0);
    numCellPts = pStrips[0];
    pLocs[0] = 0;
    nextCellPts = numCellPts + 1;
    for (vtkIdType i = 1; i < nStrips; ++i)
      {
      numCellPts = pStrips[nextCellPts];
      pLocs[i] = nextCellPts;
      nextCellPts += numCellPts + 1;
      }
    }

  // set up the cell types data structure
  this->Cells = vtkCellTypes::New();
  this->Cells->SetCellTypes(nCells, types, locs);
  this->Cells->Register(this);
  this->Cells->Delete();
  types->Delete();
  locs->Delete();
}

//----------------------------------------------------------------------------
void vtkPolyData::DeleteLinks()
{
  if (this->Links)
    {
    this->Links->UnRegister( this );
    this->Links = NULL;
    }
}

//----------------------------------------------------------------------------
// Create upward links from points to cells that use each point. Enables
// topologically complex queries.
void vtkPolyData::BuildLinks(int initialSize)
{
  if ( this->Links )
    {
    this->DeleteLinks();
    }

  if ( this->Cells == NULL )
    {
    this->BuildCells();
    }

  this->Links = vtkCellLinks::New();
  if ( initialSize > 0 )
    {
    this->Links->Allocate(initialSize);
    }
  else
    {
    this->Links->Allocate(this->GetNumberOfPoints());
    }
  this->Links->Register(this);
  this->Links->Delete();

  this->Links->BuildLinks(this);
}

//----------------------------------------------------------------------------
// Copy a cells point ids into list provided. (Less efficient.)
void vtkPolyData::GetCellPoints(vtkIdType cellId, vtkIdList *ptIds)
{
  vtkIdType i;
  vtkIdType *pts, npts;

  ptIds->Reset();
  if ( this->Cells == NULL )
    {
    this->BuildCells();
    }

  this->vtkPolyData::GetCellPoints(cellId, npts, pts);
  ptIds->InsertId (npts-1,pts[npts-1]);
  for (i=0; i<npts-1; i++)
    {
    ptIds->SetId(i,pts[i]);
    }
}

//----------------------------------------------------------------------------
void vtkPolyData::GetPointCells(vtkIdType ptId, vtkIdList *cellIds)
{
  vtkIdType *cells;
  vtkIdType numCells;
  vtkIdType i;

  if ( ! this->Links )
    {
    this->BuildLinks();
    }
  cellIds->Reset();

  numCells = this->Links->GetNcells(ptId);
  cells = this->Links->GetCells(ptId);

  for (i=0; i < numCells; i++)
    {
    cellIds->InsertId(i,cells[i]);
    }
}

//----------------------------------------------------------------------------
// Method allocates initial storage for vertex, line, polygon, and
// triangle strip arrays. Use this method before the method
// PolyData::InsertNextCell(). (Or, provide vertex, line, polygon, and
// triangle strip cell arrays.)
void vtkPolyData::Allocate(vtkIdType numCells, int extSize)
{
  vtkCellArray *cells;

  if (!this->Cells)
    {
    this->Cells = vtkCellTypes::New();
    this->Cells->Allocate(numCells,3*numCells);
    // Consistent Register/UnRegister. (ShallowCopy).
    this->Cells->Register(this);
    this->Cells->Delete();
    }

  cells = vtkCellArray::New();
  cells->Allocate(numCells,extSize);
  this->SetVerts(cells);
  cells->Delete();

  cells = vtkCellArray::New();
  cells->Allocate(numCells,extSize);
  this->SetLines(cells);
  cells->Delete();

  cells = vtkCellArray::New();
  cells->Allocate(numCells,extSize);
  this->SetPolys(cells);
  cells->Delete();

  cells = vtkCellArray::New();
  cells->Allocate(numCells,extSize);
  this->SetStrips(cells);
  cells->Delete();
}

void vtkPolyData::Allocate(vtkPolyData *inPolyData, vtkIdType numCells,
                           int extSize)
{
  vtkCellArray *cells;
  int numVerts=inPolyData->GetVerts()->GetNumberOfCells();
  int numLines=inPolyData->GetLines()->GetNumberOfCells();
  int numPolys=inPolyData->GetPolys()->GetNumberOfCells();
  int numStrips=inPolyData->GetStrips()->GetNumberOfCells();
  int total=numVerts+numLines+numPolys+numStrips;

  if ( total <= 0 )
    {
    return;
    }

  if (!this->Cells)
    {
    this->Cells = vtkCellTypes::New();
    this->Cells->Allocate(numCells,3*numCells);
    // Consistent Register/UnRegister. (ShallowCopy).
    this->Cells->Register(this);
    this->Cells->Delete();
    }

  if ( numVerts > 0 )
    {
    cells = vtkCellArray::New();
    cells->Allocate(
      static_cast<int>(static_cast<double>(numVerts)/total*numCells),extSize);
    this->SetVerts(cells);
    cells->Delete();
    }
  if ( numLines > 0 )
    {
    cells = vtkCellArray::New();
    cells->Allocate(
      static_cast<int>(static_cast<double>(numLines)/total*numCells),extSize);
    this->SetLines(cells);
    cells->Delete();
    }
  if ( numPolys > 0 )
    {
    cells = vtkCellArray::New();
    cells->Allocate(
      static_cast<int>(static_cast<double>(numPolys)/total*numCells),extSize);
    this->SetPolys(cells);
    cells->Delete();
    }
  if ( numStrips > 0 )
    {
    cells = vtkCellArray::New();
    cells->Allocate(
      static_cast<int>(static_cast<double>(numStrips)/total*numCells),extSize);
    this->SetStrips(cells);
    cells->Delete();
    }
}

//----------------------------------------------------------------------------
// Insert a cell of type VTK_VERTEX, VTK_POLY_VERTEX, VTK_LINE, VTK_POLY_LINE,
// VTK_TRIANGLE, VTK_QUAD, VTK_POLYGON, or VTK_TRIANGLE_STRIP.  Make sure that
// the PolyData::Allocate() function has been called first or that vertex,
// line, polygon, and triangle strip arrays have been supplied.
// Note: will also insert VTK_PIXEL, but converts it to VTK_QUAD.
vtkIdType vtkPolyData::InsertNextCell(int type, int npts, vtkIdType *pts)
{
  int id;

  if ( !this->Cells )
    {
    // if we get to this point, the user has not made any guess at the
    // number of cells, so this guess is as good as any
    this->Cells = vtkCellTypes::New();
    this->Cells->Allocate(5000,10000);
    }

  switch (type)
    {
    case VTK_VERTEX: case VTK_POLY_VERTEX:
      this->Verts->InsertNextCell(npts,pts);
      id = this->Cells->InsertNextCell(type,
                                       this->Verts->GetInsertLocation(npts));
      break;

    case VTK_LINE: case VTK_POLY_LINE:
      this->Lines->InsertNextCell(npts,pts);
      id = this->Cells->InsertNextCell(type,
                                       this->Lines->GetInsertLocation(npts));
      break;

    case VTK_TRIANGLE: case VTK_QUAD: case VTK_POLYGON:
      this->Polys->InsertNextCell(npts,pts);
      id = this->Cells->InsertNextCell(type,
                                       this->Polys->GetInsertLocation(npts));
      break;

    case VTK_PIXEL: //need to rearrange vertices
      {
      vtkIdType pixPts[4];
      pixPts[0] = pts[0];
      pixPts[1] = pts[1];
      pixPts[2] = pts[3];
      pixPts[3] = pts[2];
      this->Polys->InsertNextCell(npts,pixPts);
      id = this->Cells->InsertNextCell(VTK_QUAD,
                                       this->Polys->GetInsertLocation(npts));
      break;
      }

    case VTK_TRIANGLE_STRIP:
      this->Strips->InsertNextCell(npts,pts);
      id = this->Cells->InsertNextCell(type,
                                       this->Strips->GetInsertLocation(npts));
      break;

    default:
      id = -1;
      vtkErrorMacro(<<""Bad cell type! Can't insert!"");
    }
  return id;
}

//----------------------------------------------------------------------------
// Insert a cell of type VTK_VERTEX, VTK_POLY_VERTEX, VTK_LINE, VTK_POLY_LINE,
// VTK_TRIANGLE, VTK_QUAD, VTK_POLYGON, or VTK_TRIANGLE_STRIP.  Make sure that
// the PolyData::Allocate() function has been called first or that vertex,
// line, polygon, and triangle strip arrays have been supplied.
// Note: will also insert VTK_PIXEL, but converts it to VTK_QUAD.
vtkIdType vtkPolyData::InsertNextCell(int type, vtkIdList *pts)
{
  vtkIdType id;
  vtkIdType npts = pts->GetNumberOfIds();

  if ( !this->Cells )
    {
    this->Cells = vtkCellTypes::New();
    this->Cells->Allocate(5000,10000);
    }

  switch (type)
    {
    case VTK_VERTEX: case VTK_POLY_VERTEX:
      this->Verts->InsertNextCell(pts);
      id = this->Cells->InsertNextCell(type, this->Verts->GetInsertLocation(npts));
      break;

    case VTK_LINE: case VTK_POLY_LINE:
      this->Lines->InsertNextCell(pts);
      id = this->Cells->InsertNextCell(type, this->Lines->GetInsertLocation(npts));
      break;

    case VTK_TRIANGLE: case VTK_QUAD: case VTK_POLYGON:
      this->Polys->InsertNextCell(pts);
      id = this->Cells->InsertNextCell(type, this->Polys->GetInsertLocation(npts));
      break;

    case VTK_PIXEL: //need to rearrange vertices
      {
      vtkIdType pixPts[4];
      pixPts[0] = pts->GetId(0);
      pixPts[1] = pts->GetId(1);
      pixPts[2] = pts->GetId(3);
      pixPts[3] = pts->GetId(2);
      this->Polys->InsertNextCell(4,pixPts);
      id = this->Cells->InsertNextCell(VTK_QUAD, this->Polys->GetInsertLocation(npts));
      break;
      }

    case VTK_TRIANGLE_STRIP:
      this->Strips->InsertNextCell(pts);
      id = this->Cells->InsertNextCell(type, this->Strips->GetInsertLocation(npts));
      break;

    case VTK_EMPTY_CELL:
      id = -1;
      // do nothing
      break;

    default:
      id = -1;
      vtkErrorMacro(<<""Bad cell type! Can't insert!"");
    }

  return id;
}

//----------------------------------------------------------------------------
// Recover extra allocated memory when creating data whose initial size
// is unknown. Examples include using the InsertNextCell() method, or
// when using the CellArray::EstimateSize() method to create vertices,
// lines, polygons, or triangle strips.
void vtkPolyData::Squeeze()
{
  if ( this->Verts != NULL )
    {
    this->Verts->Squeeze();
    }
  if ( this->Lines != NULL )
    {
    this->Lines->Squeeze();
    }
  if ( this->Polys != NULL )
    {
    this->Polys->Squeeze();
    }
  if ( this->Strips != NULL )
    {
    this->Strips->Squeeze();
    }

  vtkPointSet::Squeeze();
}

//----------------------------------------------------------------------------
// Begin inserting data all over again. Memory is not freed but otherwise
// objects are returned to their initial state.
void vtkPolyData::Reset()
{
  if ( this->Verts != NULL )
    {
    this->Verts->Reset();
    }
  if ( this->Lines != NULL )
    {
    this->Lines->Reset();
    }
  if ( this->Polys != NULL )
    {
    this->Polys->Reset();
    }
  if ( this->Strips != NULL )
    {
    this->Strips->Reset();
    }
}

//----------------------------------------------------------------------------
// Reverse the order of point ids defining the cell.
void vtkPolyData::ReverseCell(vtkIdType cellId)
{
  int loc, type;

  if ( this->Cells == NULL )
    {
    this->BuildCells();
    }
  loc = this->Cells->GetCellLocation(cellId);
  type = this->Cells->GetCellType(cellId);

  switch (type)
    {
    case VTK_VERTEX: case VTK_POLY_VERTEX:
     this->Verts->ReverseCell(loc);
     break;

    case VTK_LINE: case VTK_POLY_LINE:
      this->Lines->ReverseCell(loc);
      break;

    case VTK_TRIANGLE: case VTK_QUAD: case VTK_POLYGON:
      this->Polys->ReverseCell(loc);
      break;

    case VTK_TRIANGLE_STRIP:
      this->Strips->ReverseCell(loc);
      break;

    default:
      break;
    }
}

//----------------------------------------------------------------------------
// Add a point to the cell data structure (after cell pointers have been
// built). This method allocates memory for the links to the cells.  (To
// use this method, make sure points are available and BuildLinks() has been invoked.)
vtkIdType vtkPolyData::InsertNextLinkedPoint(int numLinks)
{
  return this->Links->InsertNextPoint(numLinks);
}

//----------------------------------------------------------------------------
// Add a point to the cell data structure (after cell pointers have been
// built). This method adds the point and then allocates memory for the
// links to the cells.  (To use this method, make sure points are available
// and BuildLinks() has been invoked.)
vtkIdType vtkPolyData::InsertNextLinkedPoint(double x[3], int numLinks)
{
  this->Links->InsertNextPoint(numLinks);
  return this->Points->InsertNextPoint(x);
}

//----------------------------------------------------------------------------
// Add a new cell to the cell data structure (after cell pointers have been
// built). This method adds the cell and then updates the links from the points
// to the cells. (Memory is allocated as necessary.)
vtkIdType vtkPolyData::InsertNextLinkedCell(int type, int npts, vtkIdType *pts)
{
  vtkIdType i, id;

  id = this->InsertNextCell(type,npts,pts);

  for (i=0; i<npts; i++)
    {
    this->Links->ResizeCellList(pts[i],1);
    this->Links->AddCellReference(id,pts[i]);
    }

  return id;
}

//----------------------------------------------------------------------------
// Remove a reference to a cell in a particular point's link list. You may also
// consider using RemoveCellReference() to remove the references from all the
// cell's points to the cell. This operator does not reallocate memory; use the
// operator ResizeCellList() to do this if necessary.
void vtkPolyData::RemoveReferenceToCell(vtkIdType ptId, vtkIdType cellId)
{
  this->Links->RemoveCellReference(cellId, ptId);
}

//----------------------------------------------------------------------------
// Add a reference to a cell in a particular point's link list. (You may also
// consider using AddCellReference() to add the references from all the
// cell's points to the cell.) This operator does not realloc memory; use the
// operator ResizeCellList() to do this if necessary.
void vtkPolyData::AddReferenceToCell(vtkIdType ptId, vtkIdType cellId)
{
  this->Links->AddCellReference(cellId, ptId);
}

//----------------------------------------------------------------------------
// Replace the points defining cell ""cellId"" with a new set of points. This
// operator is (typically) used when links from points to cells have not been
// built (i.e., BuildLinks() has not been executed). Use the operator
// ReplaceLinkedCell() to replace a cell when cell structure has been built.
void vtkPolyData::ReplaceCell(vtkIdType cellId, int npts, vtkIdType *pts)
{
  int loc, type;

  if ( this->Cells == NULL )
    {
    this->BuildCells();
    }
  loc = this->Cells->GetCellLocation(cellId);
  type = this->Cells->GetCellType(cellId);

  switch (type)
    {
    case VTK_VERTEX: case VTK_POLY_VERTEX:
     this->Verts->ReplaceCell(loc,npts,pts);
     break;

    case VTK_LINE: case VTK_POLY_LINE:
      this->Lines->ReplaceCell(loc,npts,pts);
      break;

    case VTK_TRIANGLE: case VTK_QUAD: case VTK_POLYGON:
      this->Polys->ReplaceCell(loc,npts,pts);
      break;

    case VTK_TRIANGLE_STRIP:
      this->Strips->ReplaceCell(loc,npts,pts);
      break;

    default:
      break;
    }
}

//----------------------------------------------------------------------------
// Replace one cell with another in cell structure. This operator updates the
// connectivity list and the point's link list. It does not delete references
// to the old cell in the point's link list. Use the operator
// RemoveCellReference() to delete all references from points to (old) cell.
// You may also want to consider using the operator ResizeCellList() if the
// link list is changing size.
void vtkPolyData::ReplaceLinkedCell(vtkIdType cellId, int npts, vtkIdType *pts)
{
  int loc = this->Cells->GetCellLocation(cellId);
  int type = this->Cells->GetCellType(cellId);

  switch (type)
    {
    case VTK_VERTEX: case VTK_POLY_VERTEX:
     this->Verts->ReplaceCell(loc,npts,pts);
     break;

    case VTK_LINE: case VTK_POLY_LINE:
      this->Lines->ReplaceCell(loc,npts,pts);
      break;

    case VTK_TRIANGLE: case VTK_QUAD: case VTK_POLYGON:
      this->Polys->ReplaceCell(loc,npts,pts);
      break;

    case VTK_TRIANGLE_STRIP:
      this->Strips->ReplaceCell(loc,npts,pts);
      break;

    default:
      npts = 0;
    }

  for (int i=0; i < npts; i++)
    {
    this->Links->InsertNextCellReference(pts[i],cellId);
    }
}

//----------------------------------------------------------------------------
// Get the neighbors at an edge. More efficient than the general
// GetCellNeighbors(). Assumes links have been built (with BuildLinks()),
// and looks specifically for edge neighbors.
void vtkPolyData::GetCellEdgeNeighbors(vtkIdType cellId, vtkIdType p1,
                                       vtkIdType p2, vtkIdList *cellIds)
{
  cellIds->Reset();

  const vtkCellLinks::Link &link1(this->Links->GetLink(p1));
  const vtkCellLinks::Link &link2(this->Links->GetLink(p2));

  const vtkIdType *cells1 = link1.cells;
  const vtkIdType *cells1End = cells1 + link1.ncells;

  const vtkIdType *cells2 = link2.cells;
  const vtkIdType *cells2End = cells2 + link2.ncells;

  while (cells1 != cells1End)
    {
    if (*cells1 != cellId)
      {
      const vtkIdType *cells2Cur(cells2);
      while (cells2Cur != cells2End)
        {
        if (*cells1 == *cells2Cur)
          {
          cellIds->InsertNextId(*cells1);
          break;
          }
        ++cells2Cur;
        }
      }
    ++cells1;
    }
}

//----------------------------------------------------------------------------
void vtkPolyData::GetCellNeighbors(vtkIdType cellId, vtkIdList *ptIds,
                                   vtkIdList *cellIds)
{
  vtkIdType i, j, numPts, cellNum;
  int allFound, oneFound;

  if ( ! this->Links )
    {
    this->BuildLinks();
    }

  cellIds->Reset();

  // load list with candidate cells, remove current cell
  vtkIdType ptId = ptIds->GetId(0);
  int numPrime = this->Links->GetNcells(ptId);
  vtkIdType *primeCells = this->Links->GetCells(ptId);
  numPts = ptIds->GetNumberOfIds();

  // for each potential cell
  for (cellNum = 0; cellNum < numPrime; cellNum++)
    {
    // ignore the original cell
    if (primeCells[cellNum] != cellId)
      {
      // are all the remaining points in the cell ?
      for (allFound=1, i=1; i < numPts && allFound; i++)
        {
        ptId = ptIds->GetId(i);
        int numCurrent = this->Links->GetNcells(ptId);
        vtkIdType *currentCells = this->Links->GetCells(ptId);
        oneFound = 0;
        for (j = 0; j < numCurrent; j++)
          {
          if (primeCells[cellNum] == currentCells[j])
            {
            oneFound = 1;
            break;
            }
          }
        if (!oneFound)
          {
          allFound = 0;
          }
        }
      if (allFound)
        {
        cellIds->InsertNextId(primeCells[cellNum]);
        }
      }
    }
}

int vtkPolyData::IsEdge(vtkIdType p1, vtkIdType p2)
{
  unsigned short int ncells;
  vtkIdType cellType;
  vtkIdType npts;
  vtkIdType i, j;
  vtkIdType *cells, *pts;

  vtkIdType nbPoints = this->GetNumberOfPoints();
  if (p1 >= nbPoints || p2 >= nbPoints)
    {
    return 0;
    }

  this->GetPointCells(p1,ncells,cells);
  for (i=0; i<ncells; i++)
    {
    cellType = this->GetCellType(cells[i]);
    switch (cellType)
      {
      case VTK_EMPTY_CELL: case VTK_VERTEX: case VTK_POLY_VERTEX: case VTK_LINE: case VTK_POLY_LINE:
        break;
      case VTK_TRIANGLE:
        if ( this->IsPointUsedByCell(p2,cells[i]) )
          {
          return 1;
          }
        break;
      case VTK_QUAD:
        this->GetCellPoints(cells[i],npts,pts);
        for (j=0; j<npts-1; j++)
          {
          if (((pts[j]==p1)&&(pts[j+1]==p2))||((pts[j]==p2)&&(pts[j+1]==p1)))
            {
            return 1;
            }
          }
        if (((pts[0]==p1)&&(pts[npts-1]==p2))||((pts[0]==p2)&&(pts[npts-1]==p1)))
          {
          return 1;
          }
        break;
      case VTK_TRIANGLE_STRIP:
        this->GetCellPoints(cells[i],npts,pts);
        for (j=0; j<npts-2; j++)
          {
          if ((((pts[j]==p1)&&(pts[j+1]==p2))||((pts[j]==p2)&&(pts[j+1]==p1)))||
              (((pts[j]==p1)&&(pts[j+2]==p2))||((pts[j]==p2)&&(pts[j+2]==p1))))
            {
            return 1;
            }
          }
        if (((pts[npts-2]==p1)&&(pts[npts-1]==p2))||((pts[npts-2]==p2)&&(pts[npts-1]==p1)))
          {
          return 1;
          }
        break;
      default:
        this->GetCellPoints(cells[i],npts,pts);
        for (j=0; j<npts; j++)
          {
          if (p1==pts[j])
            {
            if ((pts[(j-1+npts)%npts]==p2)||(pts[(j+1)%npts]==p2))
              {
              return 1;
              }
            }
          }
      }
    }
  return 0;
}

//----------------------------------------------------------------------------

unsigned long vtkPolyData::GetActualMemorySize()
{
  unsigned long size=this->vtkPointSet::GetActualMemorySize();
  if ( this->Verts )
    {
    size += this->Verts->GetActualMemorySize();
    }
  if ( this->Lines )
    {
    size += this->Lines->GetActualMemorySize();
    }
  if ( this->Polys )
    {
    size += this->Polys->GetActualMemorySize();
    }
  if ( this->Strips )
    {
    size += this->Strips->GetActualMemorySize();
    }
  if ( this->Cells )
    {
    size += this->Cells->GetActualMemorySize();
    }
  if ( this->Links )
    {
    size += this->Links->GetActualMemorySize();
    }
  return size;
}

//----------------------------------------------------------------------------
void vtkPolyData::ShallowCopy(vtkDataObject *dataObject)
{
  vtkPolyData *polyData = vtkPolyData::SafeDownCast(dataObject);
  if (this == polyData)
     return;

  if ( polyData != NULL )
    {
    this->SetVerts(polyData->GetVerts());
    this->SetLines(polyData->GetLines());
    this->SetPolys(polyData->GetPolys());
    this->SetStrips(polyData->GetStrips());

    // I do not know if this is correct but.
    if (this->Cells)
      {
      this->Cells->UnRegister(this);
      }
    this->Cells = polyData->Cells;
    if (this->Cells)
      {
      this->Cells->Register(this);
      }

    if (this->Links)
      {
      this->Links->Delete();
      }
    this->Links = polyData->Links;
    if (this->Links)
      {
      this->Links->Register(this);
      }
    }

  // Do superclass
  this->vtkPointSet::ShallowCopy(dataObject);
}

//----------------------------------------------------------------------------
void vtkPolyData::DeepCopy(vtkDataObject *dataObject)
{
  // Do superclass
  // We have to do this BEFORE we call BuildLinks, else there are no points
  // to build the links on (the parent DeepCopy copies the points)
  this->vtkPointSet::DeepCopy(dataObject);

  vtkPolyData *polyData = vtkPolyData::SafeDownCast(dataObject);

  if ( polyData != NULL )
    {
    vtkCellArray *ca;
    ca = vtkCellArray::New();
    ca->DeepCopy(polyData->GetVerts());
    this->SetVerts(ca);
    ca->Delete();

    ca = vtkCellArray::New();
    ca->DeepCopy(polyData->GetLines());
    this->SetLines(ca);
    ca->Delete();

    ca = vtkCellArray::New();
    ca->DeepCopy(polyData->GetPolys());
    this->SetPolys(ca);
    ca->Delete();

    ca = vtkCellArray::New();
    ca->DeepCopy(polyData->GetStrips());
    this->SetStrips(ca);
    ca->Delete();

    if ( this->Cells )
      {
      this->Cells->UnRegister(this);
      this->Cells = NULL;
      }
    if (polyData->Cells)
      {
      this->BuildCells();
      }

    if ( this->Links )
      {
      this->Links->UnRegister(this);
      this->Links = NULL;
      }
    if (polyData->Links)
      {
      this->BuildLinks();
      }
    }
}

void vtkPolyData::RemoveGhostCells()
{
  // Get a pointer to the cell ghost level array.
  vtkUnsignedCharArray* temp = this->GetCellGhostArray();
  if (temp == NULL)
    {
    vtkDebugMacro(""Could not find cell ghost array."");
    return;
    }
  if (temp->GetNumberOfComponents() != 1 ||
      temp->GetNumberOfTuples() < this->GetNumberOfCells())
    {
    vtkErrorMacro(""Poorly formed ghost array."");
    return;
    }
  unsigned char* cellGhosts = temp->GetPointer(0);

  vtkIdType numCells = this->GetNumberOfCells();

  vtkIntArray *types = vtkIntArray::New();
  types->SetNumberOfValues(numCells);

  for (vtkIdType i = 0; i < numCells; i++)
    {
    types->SetValue(i, this->GetCellType(i));
    }

  this->DeleteCells();

  // we have to make new copies of Verts, Lines, Polys
  // and Strips since they may be shared with other polydata
  vtkSmartPointer<vtkCellArray> verts;
  if(this->Verts)
    {
    verts = this->Verts;
    verts->InitTraversal();
    this->Verts->UnRegister(this);
    this->Verts = vtkCellArray::New();
    }

  vtkSmartPointer<vtkCellArray> lines;
  if(this->Lines)
    {
    lines = this->Lines;
    lines->InitTraversal();
    this->Lines->UnRegister(this);
    this->Lines = vtkCellArray::New();
    }

  vtkSmartPointer<vtkCellArray> polys;
  if(this->Polys)
    {
    polys = this->Polys;
    polys->InitTraversal();
    this->Polys->UnRegister(this);
    this->Polys = vtkCellArray::New();
    }

  vtkSmartPointer<vtkCellArray> strips;
  if(this->Strips)
    {
    strips = this->Strips;
    strips->InitTraversal();
    this->Strips->UnRegister(this);
    this->Strips = vtkCellArray::New();
    }

  vtkCellData *newCellData = vtkCellData::New();
  newCellData->CopyAllocate(this->CellData, numCells);

  vtkIdType *pts, n;

  int cellId;

  for (vtkIdType i = 0; i < numCells; i++)
    {
    int type = types->GetValue(i);

    if (type == VTK_VERTEX || type == VTK_POLY_VERTEX)
      {
      verts->GetNextCell(n, pts);

      if (! (cellGhosts[i] & vtkDataSetAttributes::DUPLICATECELL))
        {
        cellId = this->InsertNextCell(type, n, pts);
        newCellData->CopyData(this->CellData, i, cellId);
        }
      }
    else if (type == VTK_LINE || type == VTK_POLY_LINE)
      {
      lines->GetNextCell(n, pts);

      if (! (cellGhosts[i] & vtkDataSetAttributes::DUPLICATECELL))
        {
        cellId = this->InsertNextCell(type, n, pts);
        newCellData->CopyData(this->CellData, i, cellId);
        }
      }
    else if (type == VTK_POLYGON || type == VTK_TRIANGLE || type == VTK_QUAD)
      {
      polys->GetNextCell(n, pts);

      if (! (cellGhosts[i] & vtkDataSetAttributes::DUPLICATECELL))
        {
        cellId = this->InsertNextCell(type, n, pts);
        newCellData->CopyData(this->CellData, i, cellId);
        }
      }
    else if (type == VTK_TRIANGLE_STRIP)
      {
      strips->GetNextCell(n, pts);

      if (! (cellGhosts[i] & vtkDataSetAttributes::DUPLICATECELL))
        {
        cellId = this->InsertNextCell(type, n, pts);
        newCellData->CopyData(this->CellData, i, cellId);
        }
      }
    }

  newCellData->Squeeze();

  this->CellData->ShallowCopy(newCellData);
  newCellData->Delete();

  types->Delete();

  // If there are no more ghost levels, then remove all arrays.
  this->CellData->RemoveArray(vtkDataSetAttributes::GhostArrayName());

  this->Squeeze();
}
//----------------------------------------------------------------------------
void vtkPolyData::RemoveDeletedCells()
{
  if (!this->Cells)
    {
      return;
    }

  vtkNew<vtkPolyData> oldData;
  oldData->ShallowCopy(this);
  this->DeleteCells();

  if(this->Verts)
    {
    this->Verts->UnRegister(this);
    this->Verts = vtkCellArray::New();
    }
  if(this->Lines)
    {
    this->Lines->UnRegister(this);
    this->Lines = vtkCellArray::New();
    }
  if(this->Polys)
    {
    this->Polys->UnRegister(this);
    this->Polys = vtkCellArray::New();
    }
  if(this->Strips)
    {
    this->Strips->UnRegister(this);
    this->Strips = vtkCellArray::New();
    }

  this->CellData->CopyAllocate(oldData->GetCellData());

  const vtkIdType numCells = oldData->GetNumberOfCells();
  vtkCell *cell;
  vtkIdType cellId;
  vtkIdList *pointIds;
  int type;
  for (vtkIdType i = 0; i < numCells; i++)
    {
    type = oldData->GetCellType(i);

    if (type != VTK_EMPTY_CELL)
      {
      cell = oldData->GetCell(i);
      pointIds = cell->GetPointIds();
      cellId = this->InsertNextCell(type, pointIds);
      this->CellData->CopyData(oldData->GetCellData(), i, cellId);
      }
    }

  this->CellData->Squeeze();
}
//----------------------------------------------------------------------------
vtkPolyData* vtkPolyData::GetData(vtkInformation* info)
{
  return info? vtkPolyData::SafeDownCast(info->Get(DATA_OBJECT())) : 0;
}

//----------------------------------------------------------------------------
vtkPolyData* vtkPolyData::GetData(vtkInformationVector* v, int i)
{
  return vtkPolyData::GetData(v->GetInformationObject(i));
}

//----------------------------------------------------------------------------
void vtkPolyData::PrintSelf(ostream& os, vtkIndent indent)
{
  this->Superclass::PrintSelf(os,indent);

  os << indent << ""Number Of Vertices: "" << this->GetNumberOfVerts() << ""\\n"";
  os << indent << ""Number Of Lines: "" << this->GetNumberOfLines() << ""\\n"";
  os << indent << ""Number Of Polygons: "" << this->GetNumberOfPolys() << ""\\n"";
  os << indent << ""Number Of Triangle Strips: "" << this->GetNumberOfStrips() << ""\\n"";

  os << indent << ""Number Of Pieces: "" << this->GetNumberOfPieces() << endl;
  os << indent << ""Piece: "" << this->GetPiece() << endl;
  os << indent << ""Ghost Level: "" << this->GetGhostLevel() << endl;
}


//----------------------------------------------------------------------------
int vtkPolyData::GetScalarFieldCriticalIndex (vtkIdType pointId,
                                              vtkDataArray *scalarField)
{
  /*
   * implements scalar field critical point classification for manifold
   * 2D meshes.
   */

  /*
   * returned value:
   *   -4: no such field
   *   -3: attribute check failed
   *   -2: non 2-manifold star
   *   -1: regular point
   *   0: minimum
   *   1: saddle
   *   2: maximum
   */

  bool  is_min = true, is_max = true;
  vtkIdList *starTriangleList = vtkIdList::New(),
            *lowerLinkPointList = vtkIdList::New(),
            *upperLinkPointList = vtkIdList::New(),
            *pointList = NULL;
  double pointFieldValue = scalarField->GetComponent(pointId, 0),
         neighborFieldValue = 0;

  if(this->GetNumberOfPoints() != scalarField->GetSize())
    return vtkPolyData::ERR_INCORRECT_FIELD;

  /* make sure the connectivity is built */
  if(!this->Links) this->BuildLinks();

  /* build the lower and upper links */
  this->GetPointCells(pointId, starTriangleList);
  int starNb = starTriangleList->GetNumberOfIds();
  for(int i = 0; i < starNb; i++)
    {
    vtkCell *c = this->GetCell(starTriangleList->GetId(i));
    pointList = c->GetPointIds();
    int pointNb = pointList->GetNumberOfIds();
    if(pointNb != 3)
      {
      starTriangleList->Delete();
      lowerLinkPointList->Delete();
      upperLinkPointList->Delete();
      return vtkPolyData::ERR_NON_MANIFOLD_STAR;
      }

    for(int j = 0; j < pointNb; j++)
      {
      vtkIdType  currentPointId = pointList->GetId(j);

      /* quick check for extrema */
      neighborFieldValue = scalarField->GetComponent(currentPointId, 0);
      if((currentPointId != pointId)&&(neighborFieldValue == pointFieldValue))
        {
        /* simulation of simplicity (Edelsbrunner et al. ACM ToG 1990) */
        if(currentPointId > pointId)
          {
          is_max = false;
          upperLinkPointList->InsertUniqueId(currentPointId);
          }
        if(currentPointId < pointId)
          {
          is_min = false;
          lowerLinkPointList->InsertUniqueId(currentPointId);
          }
        }
      else
        {
        if(neighborFieldValue > pointFieldValue)
          {
          is_max = false;
          upperLinkPointList->InsertUniqueId(currentPointId);
          }
        if(neighborFieldValue < pointFieldValue)
          {
          is_min = false;
          lowerLinkPointList->InsertUniqueId(currentPointId);
          }
        }
      }
    }

  if((is_max)||(is_min))
    {
    starTriangleList->Delete();
    lowerLinkPointList->Delete();
    upperLinkPointList->Delete();
    if(is_max) return vtkPolyData::MAXIMUM;
    if(is_min) return vtkPolyData::MINIMUM;
    }

  /*
   * is the vertex really regular?
   * (lower and upper links are BOTH simply connected)
   */
  int visitedPointNb = 0, stackBottom = 0,
      lowerLinkPointNb = lowerLinkPointList->GetNumberOfIds(),
      upperLinkPointNb = upperLinkPointList->GetNumberOfIds();

  /* first, check lower link's simply connectedness */
  vtkIdList *stack = vtkIdList::New();
  stack->InsertUniqueId(lowerLinkPointList->GetId(0));
  vtkIdType currentPointId = stack->GetId(stackBottom), nextPointId = -1;
  do
    {
    stackBottom++;
    vtkIdList *triangleList = vtkIdList::New();
    this->GetPointCells(currentPointId, triangleList);
    int triangleNb = triangleList->GetNumberOfIds();

    for(int i = 0; i < triangleNb; i++)
      {
      vtkCell *c = this->GetCell(triangleList->GetId(i));
      pointList = c->GetPointIds();;
      int pointNb = pointList->GetNumberOfIds();

      if(pointList->IsId(pointId) >= 0)
        {
        // those two triangles are in the star of pointId
        int j = 0;
        do
          {
          nextPointId = pointList->GetId(j);
          j++;
          }while(((nextPointId == pointId)
          ||(nextPointId == currentPointId))&&(j < pointNb ));
        }

      if(lowerLinkPointList->IsId(nextPointId) >= 0)
        {
        stack->InsertUniqueId(nextPointId);
        }

      }

    triangleList->Delete();
    visitedPointNb++;

    currentPointId = stack->GetId(stackBottom);
    nextPointId = -1;

  }while(stackBottom < stack->GetNumberOfIds());

  if(visitedPointNb != lowerLinkPointNb)
    {
    // the lower link is not simply connected, then it's a saddle
    stack->Delete();
    starTriangleList->Delete();
    lowerLinkPointList->Delete();
    upperLinkPointList->Delete();
    return vtkPolyData::SADDLE;
    }

  /*
   * then, check upper link's simply connectedness.
   * BOTH need to be checked if the 2-manifold has boundary components.
   */
  stackBottom = 0;
  visitedPointNb = 0;
  stack->Delete();
  stack = vtkIdList::New();
  stack->InsertUniqueId(upperLinkPointList->GetId(0));
  currentPointId = stack->GetId(stackBottom);
  nextPointId = -1;
  do
    {
    stackBottom++;
    vtkIdList *triangleList = vtkIdList::New();
    this->GetPointCells(currentPointId, triangleList);
    int triangleNb = triangleList->GetNumberOfIds();

    for(int i = 0; i < triangleNb; i++)
      {
      vtkCell *c = this->GetCell(triangleList->GetId(i));
      pointList = c->GetPointIds();
      int pointNb = pointList->GetNumberOfIds();

      if(pointList->IsId(pointId) >= 0)
        {
        // those two triangles are in the star of pointId
        int j = 0;
        do
          {
          nextPointId = pointList->GetId(j);
          j++;
          }while(((nextPointId == pointId)
          ||(nextPointId == currentPointId))&&(j < pointNb));
        }

      if(upperLinkPointList->IsId(nextPointId) >= 0)
        {
        stack->InsertUniqueId(nextPointId);
        }
      }

    triangleList->Delete();
    visitedPointNb++;

    currentPointId = stack->GetId(stackBottom);
    nextPointId = -1;
    }while(stackBottom < stack->GetNumberOfIds());

  if(visitedPointNb != upperLinkPointNb)
    {
    // the upper link is not simply connected, then it's a saddle
    stack->Delete();
    starTriangleList->Delete();
    lowerLinkPointList->Delete();
    upperLinkPointList->Delete();
    return vtkPolyData::SADDLE;
    }

  /* else it's necessarily a regular point (only 4 cases in 2D)*/
  stack->Delete();
  starTriangleList->Delete();
  lowerLinkPointList->Delete();
  upperLinkPointList->Delete();
  return vtkPolyData::REGULAR_POINT;
}

//----------------------------------------------------------------------------
int vtkPolyData::GetScalarFieldCriticalIndex (vtkIdType pointId,
                                              const char* fieldName)
{
  /*
   * returned value:
   *   -4: no such field
   *   -3: attribute check failed
   *   -2: non 2-manifold star
   *   -1: regular point
   *   0: minimum
   *   1: saddle
   *   2: maximum
   */

  int fieldId = 0;

  vtkPointData *pointData = this->GetPointData();
  vtkDataArray *scalarField = pointData->GetArray(fieldName, fieldId);

  if(!scalarField) return vtkPolyData::ERR_NO_SUCH_FIELD;

  return this->GetScalarFieldCriticalIndex(pointId, scalarField);

}

//----------------------------------------------------------------------------
int vtkPolyData::GetScalarFieldCriticalIndex (vtkIdType pointId, int fieldId)
{
  /*
   * returned value:
   *   -4: no such field
   *   -3: attribute check failed
   *   -2: non 2-manifold star
   *   -1: regular point
   *   0: minimum
   *   1: saddle
   *   2: maximum
   */

  vtkPointData *pointData = this->GetPointData();
  vtkDataArray *scalarField = pointData->GetArray(fieldId);

  if(!scalarField) return vtkPolyData::ERR_NO_SUCH_FIELD;

  return this->GetScalarFieldCriticalIndex(pointId, scalarField);
}
",16303,True,2786.0748961194267,median
"= HMS+  User Guide
:site-section: UserGuide
:toc: left
:toc-title: Contents
:toclevels: 3
:sectnums:
:imagesDir: images
:stylesDir: stylesheets
:xrefstyle: full
:experimental:
ifdef::env-github[]
:tip-caption: :bulb:
:note-caption: :information_source:
endif::[]
:repoURL: https://github.com/cs2103-ay1819s2-t12-1/main

By: `Team T12-1`      Since: `Feb 2019`      Licence: `MIT`

// tag::introduction[]
== Introducing HMS+

You need a world-class property management system to run your hotel’s front desk and back office. We’ve spent years listening to what independent hoteliers need to take their business to the next level. From before check-in to post check out, we have everything you need to get your customers moving and your hotel running.

HMS+ is for hotels that want to use a *single, integrated system to manage all aspects of their requirements*.

This user guide provides an in-depth documentation on the HMS+ installation process, system configuration and management, monitoring and troubleshooting problems. In addition, the <<Getting Started>> will provide the basic knowledge of the setup process and how you can get started.

// end::introduction[]

== Getting Started

.  Ensure you have Java version `9` or later installed in your Computer.
.  Download the latest `hms+.jar` link:{repoURL}/releases[here].
.  Copy the file to the folder you want to use as the home folder for your Hotel Management System Plus.
.  Double-click the file to start the app. The application should appear in a few seconds.

+
image::Ui.png[width=""790""]
+
.  Type the command in the command box and press kbd:[Enter] to execute it. +
e.g. typing *`help`* and pressing kbd:[Enter] will open the help window.
.  Some example commands you can try:

* *`list-customers`* : lists all customers
* **`add-customer`**`n/John Doe p/98765432 e/johnd@example.com id/G8957685R a/John street, block 123, #01-01` : adds a customer named `John Doe` to the HMS+ database.
* **`delete-customer`**`3` : deletes the 3rd customer shown in the current list
* *`exit`* : exits the app

.  Refer to <<Features>> for details of each command.

[[Features]]
== Features

====
*Command Format*

* Words in `UPPER_CASE` are the parameters to be supplied by the user. For example, in `add n/NAME`, `NAME` is a parameter which can be used as `add n/John Doe`.
* Items in square brackets are optional. For example, `n/NAME [t/TAG]` can be used as `n/John Doe t/friend` or as `n/John Doe`.
* Items in curly brackets separated by a slash (`/`) are interchangeable (entering either of those items have the same effect). For example, `{addcustomer/ac}` are two aliases of the same command.
* Items with `…` after them can be used multiple times including zero times. For example, `[t/TAG]…` can be used as `{nbsp}` (i.e. 0 times), `t/friend`, `t/friend t/family` etc.
* Parameters can be in any order. For example, if the command specifies `n/NAME p/PHONE_NUMBER`, `p/PHONE_NUMBER n/NAME` is also acceptable.
* If you enter the same prefix twice, the data in the second prefix is recorded. For example, `n/Tejas Bhuwania n/Sanjay Bhuwania` will take in Sanjay Bhuwania inside the database.
* All commands using indexes refer to the displayed list. For example, if the displayed customer list has 2 customers and
you try to delete customer at index 3, it is an invalid command, though there are total of five customers in the database.
====

[NOTE]
====
The examples for each of the commands given below are independent of each other and do not follow a chronological order.
====

=== [underline]#Viewing help# : `help`,`hp`

Effect: Displays a help list, which lists all the commands that can be used. +
Format: `{[aqua]#help#/[aqua]#hp#}`

.Example for the `help` command
image::help-command.png[width=""800""]

=== [underline]#Customer commands#
==== Adding a customer : `add-customer`, `ac`

Effect: Adds a customer to the customer database. +
Format: `{[aqua]#add-customer#/[aqua]#ac#} [blue]#n/# [lime]#NAME# [blue]#p/# [lime]#PHONE_NUMBER# [blue]#e/# [lime]#EMAIL# [blue]#id/# [lime]#IDENTIFICATION_NO# [black]#[# [blue]#dob/# [lime]#DATE_OF_BIRTH# [black]#]# [black]#[# [blue]#a/# [lime]#ADDRESS# [black]#]# [black]#[# [blue]#t/# [lime]#TAG# [black]#]#`

[NOTE]
====
* A person needs to have the Name, Phone number, Email address and Identification number fields compulsorily.
* Any two person cannot have the same Phone number, Email address or Identification number.
* Identification number refers to NRIC/FIN number or Social Security Number (used in the US) and is therefoe a bit flexible.
* Date of birth, address and tags are optional fields. A customer can exist can without any of these.
====

[TIP]
A person can have any number of tags (including 0)

Examples:

* `ac n/John Doe p/98765432 dob/28/05/1999 e/johnd@example.com id/A5525261 a/John street, block 123, #01-01 t/Student`
   Adds the customer John Doe with the given details.

.Example for the above 'add-customer` command
image::JohnDoeadd.png[width=""800""]


* `ac n/Betsy Crowe e/betsy.crowe@example.com p/98321012 id/A3452521Q`
   Adds the customer Betsy Crowe with the given details.

.Example for the above `add-customer` command
image::BetsyCroweadd.png[width=""800""]

==== Listing all customers : `list-customers`, `lc`

Effect: Displays a customer list, which lists all customers in the customer database. +
Format: `{[aqua]#list-customers#/[aqua]#lc#}`

Examples:

* `lc` +
   Lists all the customers present in the database.

.Example for the `lc` command
image::lc.png[width=""800""]

==== Editing a customer : `edit-customer`, `ec`

Effect: Edits the fields of an existing customer in the customer database. +
Format: `{[aqua]#edit-customer/ec#} [lime]#INDEX# [black]#[# [blue]#n/# [lime]#NAME# [black]#]# [black]#[# [blue]#p/# [lime]#PHONE# [black]#]# [black]#[# [blue]#e/# [lime]#EMAIL# [black]#]# [black]#[# [blue]#id/# [lime]#IDENTIFICATION_NO# [black]#]# [black]#[# [blue]#dob/# [lime]#DATE_OF_BIRTH# [black]#]# [black]#[# [blue]#a/# [lime]#ADDRESS# [black]#]# [black]#[# [blue]#t/# [lime]#TAG#…[black]#]#`

[NOTE]
====
* Edits the customer at the specified INDEX. The index refers to the index number shown in the displayed customer list. The index must be a positive integer.
* At least one of the optional fields must be provided. Otherwise, nothing will be changed.
* Existing values will be updated to the input values.
* When editing tags, the existing tags of the customer will be removed, i.e. adding of tags is not cumulative.
====
[TIP]
You can remove all the customer's tags by typing `t/` without specifying any tags after it.

Examples:

* `lc`, then `ec 2 n/Roshani Venkatesh t/` +
Edits the name of the 2nd customer to be `Roshani Venkatesh` and clears all existing tags.

.Example before the above `ec` command
image::ec1.png[width=""800""]

.Example after the above `ec` command
image::ec2.png[width=""800""]

==== Finding customers by name: `find-name`, `fn`

Effect: Displays a customer list, which consists of customers whose names contain any of the given keywords. +
Format: `{[aqua]#find-name#/[aqua]#fn#} [lime]#KEYWORD# [black]#[# [lime]#MORE_KEYWORDS# [black]#]#`

[NOTE]
====
* The search is case insensitive, e.g `hans` will match Hans
* The order of the keywords does not matter. e.g. `Hans Bo` will match Bo Hans
* Only full words will be matched, e.g. `Han` will not match `Hans`
* Persons matching at least one keyword will be returned (i.e. `OR` search). e.g. `Hans Bo` will return Hans Gruber and Bo Yang
====

Examples:

* `find-name Vidhi` +
Returns any person having name `Vidhi`.

.Example for the `find-name Vidhi` command
image::fn1.png[width=""800""]

* `fn Tejas Vidhi Ayushi` +
Returns any person having names `Tejas`, `Vidhi` and `Ayushi`.

.Example for the `fn Tejas Vidhi Ayushi` command
image::fn2.png[width=""800""]

==== Deleting a customer : `delete-customer`, `dc`

Effect: Deletes a customer from the customer database. +
Format: `{[aqua]#delete-customer#/[aqua]#dc#} [lime]#INDEX#`

[NOTE]
====
* Deletes the customer at the specified index. The index refers to the index number shown in the displayed customer list. The index must be a positive integer.
* This command will delete all the bookings and reservations associated with the customer as well.
====

Examples:

* `list-customers`, then `delete-customer 2` +
Deletes the 2nd person of the customer database.

.Example before the `delete-customer 2` command
image::dc1a.png[width=""800""]

.Example after the `delete-customer 2` command
image::dc1b.png[width=""800""]

* `find-name Betsy Tejas`, then `delete-customer 2` +
Deletes the 2st customer in the customer list returned by the `find-name` command.

.Example after the `find-name Betsy Tejas` command
image::dc2a.png[width=""800""]

.Example after the `delete-customer 2` command
image::dc2b.png[width=""800""]


=== [underline]#Room Type commands#

==== Adding a room type : `add-room-type`, `art`

Effect: Adds a room type to hotel database. This makes it available for people to do reservations with the added room type. +
Format: `{[aqua]#add-room-type#/[aqua]#art#} [blue]#n/# [lime]#ROOM_TYPE# [blue]#cap/# [lime]#NUMBER_OF_ROOM# [blue]#rate/# [lime]#RATE#`

[NOTE]
====
* All fields are compulsory.
====

[TIP]
====
* `ROOM_TYPE` is case insensitive.
====

Example:

* `art n/FUN ROOM cap/50 rate/300.0` +
Adds a room type with name FUN ROOM, with a rate of 300.0 and capacity of 50

.Example after the `art n/FUN ROOM cap/50 rate/300.0` command
image::ast1.png[width=""800""]

==== Deleting a room type : `delete-room-type`, `drt`

Effect: Deletes a room type from the hotel database. This makes it unavailable for people to do reservations with the deleted room type. +
Format: `{[aqua]#delete-room-type#/[aqua]#drt#} [lime]#INDEX#

[CAUTION]
====
Deleting a room type also deletes all its related reservations.
====

Example:

* `drt 2` +
Deletes the room type at index 2.

.Example before the `drt 2` command
image::drt1.png[width=""800""]

.Example after the `drt 2` command
image::drt2.png[width=""800""]

==== Clearing all room types: `clear-room-type`, `crt`
Effect: Removes all room types and room reservations from the database. +
Format: `{[aqua]#clear-room-type#/[aqua]#crt#}`

Examples:

* `crt` +
Clears all room types and reservations from the database.

.Example before the `crt` command
image::crta.png[width=""800""]

.Example after the `crt` command
image::crtb.png[width=""800""]

==== Editing a room type : `edit-room-type`, `ert`

Effect: Edits the room type at the specified index. This modifies the room available to people to do reservations. +
Format: `{[aqua]#edit-room-type#/[aqua]#ert#} [lime]#INDEX# [black]#[# [blue]#n/# [lime]#ROOM_TYPE# [black]#]# [black]#[# [blue]#cap/# [lime]#NUMBER_OF_HOURS# [black]#]# [black]#[# [blue]#rate/# [lime]#RATE# [black]#]#`

Example:

* `ert 2 cap/100` +
Edits the room type at index 2 by changing the number of rooms to 100.

.Example before the `ert 2 cap/100` command
image::erta.png[width=""800""]

.Example after the `ert 2 cap/100` command
image::ertb.png[width=""800""]

// tag::reservation-commands[]
=== [underline]#Room Reservation commands#

==== Reserving a room : `add-reservation`, `ar`

Effect: Adds a reservation for a room associated with certain customers. +
Format: `{[aqua]#add-reservation#/[aqua]#ar#} [blue]#r/# [lime]#ROOM_TYPE# [blue]#d/# [lime]#START_DATE-END_DATE# [blue]#$/# [lime]#PAYER_INDEX# [black]#[# [blue]#c/# [lime]#MORE_CUSTOMER_INDICIES…# [black]#]# [black]#[# [blue]#com/# [lime]#COMMENTS# [black]#]#`

[NOTE]
====
* `ROOM_TYPE` is the name of the room type taken from the list shown in the application
* `START_DATE` and `END_DATE` follows the `DD/MM/YYYY` format.
* `COMMENTS` can contain any text without slash (/).
* All reservations can only be done from current date to upto one year from current date.
* We allow the same person to reserve the same room for the same dates. In short, we allow duplicate reservations.
* We allow different people to reserve the same room for the same date as someone else already has.
====


Examples: +
Assume current date is 10 May, 2019. +

* `list-customers`, then `ar r/SINGLE ROOM d/20/5/2019-25/5/2019 $/5` +
Adds a reservation of Single Room in the name of the 5th customer from 20 May 2019 to 25 May 2019.

.Example after the `above` command
image::ar1.png[width=""800""]

* `list-customers`, then `ar r/SHARING ROOM d/23/5/2019-25/5/2019 $/4 c/2 c/3` +
Adds a reservation of Sharing Room in the name of the 4th customer along with the 2nd and 3rd customers
 from 23 May 2019 to 25 May 2019.

.Example after the `above` command
image::ar2.png[width=""800""]

==== Listing all reservations : `list-reservations`, `lr`
Effect: Displays a reservation list, which lists all the reservations. +
Format: `{[aqua]#list-reservations#/[aqua]#lr#}`

Examples:

* `lr` +
  Lists all reservations.

.Example after the `lr` command
image::lr.png[width=""800""]

==== Editing a room reservation : `edit-reservation`, `er`

Effect: Edits the fields of an existing reservation in the reservation database. +
Format: `{[aqua]#edit-reservation#/[aqua]#er#} [lime]#INDEX# [black]#[# [blue]#r/# [lime]#ROOM_TYPE# [black]#]# [black]#[# [blue]#d/# [lime]#START_DATE-END_DATE]# [black]#]# [black]#[# [blue]#$/# [lime]#PAYER_INDEX# [black]#]# [black]#[# [blue]#c/# [lime]#MORE_CUSTOMER_INDICES# [black]#]# [black]#[# [blue]#com/# [lime]#COMMENTS# [black]#]#`

[NOTE]
====
* Edits the reservation at the specified index. The index refers to the index number shown in the displayed reservation list. The index must be a positive integer.
* At least one of the optional fields must be provided. Otherwise, nothing will be changed.
* Existing values will be updated to the input values.
* When editing comments, the existing comments of the booking will be removed, i.e adding of comments is not cumulative.
====
[TIP]
You can remove all the reservation's comments by typing `com/` without specifying any tags after it.

Examples:

* `lr`, then `er 1 r/DOUBLE ROOM` +
Edits the room type of the 1st reservation to be DOUBLE ROOM.

.Example before the `er 1 r/DOUBLE ROOM` command
image::era.png[width=""800""]

.Example after the `er 1 r/DOUBLE ROOM` command
image::erb.png[width=""800""]


* `lr`, then `er 2 d/14/02/2020-14/03/2020 com/` +
Edits the date of the 2nd reservation to be from 14 Feb 2020 to 14 Mar 2020 and clears all existing comments related to it.

==== Deleting reservations: `delete-reservation`, `dr`

Effect: Deletes a reservation from the reservation database. +
Format: `{[aqua]#delete-reservation#/[aqua]#dr#} [lime]#INDEX#`

****
* Deletes the reservation at the specified index. The index refers to the index number shown in the displayed booking list. The index must be a positive integer.
****

Examples:

* `lr`, then `dr 2` +
Deletes the 2nd entry of the reservation database.

.Example before the `dr 2` command
image::dr1.png[width=""800""]

.Example after the `dr 2` command
image::dr2.png[width=""800""]

==== Clearing all reservations: `clear-reservations`, `cr`
Effect: Removes all room reservations from the database. +
Format: `{[aqua]#clear-reservations#/[aqua]#cr#}`

Examples:

* `cr` +
Clears all reservations from the database.

.Example before the `cr` command
image::lr.png[width=""800""]

.Example after the `cr` command
image::cr.png[width=""800""]

// tag::find-reservation[]
==== Find a reservation: `find-reservation`, `fr`

Effect: Displays a reservation list based on the filters given by the user. +
Format: `{[aqua]#find-reservation#/[aqua]#fr#} [black]#[# [blue]#id/# [lime]#IDENTIFICATION_NO# [black]#]# [black]#[# [blue]#r/# [lime]#ROOM_TYPE# [black]#]# [black]#[# [blue]#d/# [lime]#START_DATE - END_DATE# [black]#]#`

[NOTE]
====
*  The searching is done in the whole reservation list.
* If you just enter the command `fr`, it displays all the reservations in the database.
====
[CAUTION]
====
* If you enter `fr d/4/6/2019 - 7/6/2019`, it displays all reservations between 4th June to 7th June. This consists of
 reservations which include the date 4th June but does not include reservations which include the date 7th June.
====

Example:
// end::find-reservation[]

* `fr id/Q000001P` +
Returns all reservations for customer with identification number, Q000001P.

.Example for the `fr id/Q000001P` command
image::fr1.png[width=""800""]

// tag::find-reservation[2]
* `fr id/Q000001P r/SHARING ROOM` +
Returns all sharing room reservations for customer with identification number, Q000001P.

.Example for the `fr id/Q000001P r/SHARING ROOM` command
image::fr2.png[width=""800""]
// end::find-reservation2[]

// end::reservation-commands[]


=== [underline]#Service Type commands#

==== Adding a service type : `add-service-type`, `ast`

Effect: Adds a service type to hotel database. This makes it available for people to do bookings with the added service type. +
Format: `{[aqua]#add-service-type#/[aqua]#ast#} [blue]#n/# [lime]#SERVICE_NAME# [blue]#cap/# [lime]#CAPACITY_OF_SERVICE# [blue]#rate/# [lime]#RATE# [blue]#:/# [lime]#OPERATIONAL_HOURS#`

[NOTE]
====
* All fields are compulsory.
* Operational hours are only between 0 - 23.
====
[TIP]
====
* `SERVICE_NAME` is case insensitive.
====

Example:

* `art n/SPA cap/50 rate/10.0 :/10-22 ` +
Adds a service type with name SPA, with a rate of 10.0 and capacity of service equal to 50 and operates from 10am to 10pm

==== Deleting a service type : `delete-service-type`, `dst`

Effect: Deletes a service type from the hotel database. This makes it unavailable for people to do bookings with the deleted service type. +
Format: `{[aqua]#delete-service-type#/[aqua]#dst#} [lime]#INDEX#

[CAUTION]
====
* Deleting a service type deletes all its related bookings too.
====

Example:

* `dst 2` +
Deletes the service type at index 2.

.Example before the `dst 2` command
image::dst1.png[width=""800""]

.Example after the `dst 2` command
image::dst2.png[width=""800""]

==== Clearing all service types: `clear-service-type`, `cst`
Effect: Removes all service types and service bookings from the database. +
Format: `{[aqua]#clear-service-type#/[aqua]#cst#}`

Examples:

* `cst` +
Clears all service types and service bookings from the database.

.Example before the `cst` command
image::cst1.png[width=""800""]

.Example after the `cst` command
image::cst2.png[width=""800""]

==== Editing a service type : `edit-service-type`, `est`

Effect: Edits the service type at the specified index. This modifies the service available to people to do bookings. +
Format: `{[aqua]#edit-service-type#/[aqua]#est#} [lime]#INDEX# [black]#[# [blue]#n/# [lime]#SERVICE_NAME# [black]#]# [black]#[# [blue]#cap/# [lime]#CAPACITY_OF_SERVICE# [black]#]# [black]#[# [blue]#rate/# [lime]#RATE# [black]#]# [black]#[# [blue]#:/# [lime]#OPERATIONAL_HOURS# [black]#]#`

Example:

* `est 2 cap/100` +
Edits the service type at index 2 by changing the capacity of the service to 100.

.Example before the `est 2` command
image::est1.png[width=""800""]

.Example after the `est 2` command
image::est2.png[width=""800""]

// tag::booking-commands[]
=== [underline]#Service Booking commands#
==== Booking a service: `add-booking`,`ab`

Effect: Adds a service associated with certain customers. +
Format: `{[aqua]#add-booking#/[aqua]#ab#} [blue]#s/# [lime]#SERVICE_NAME# [blue]#:/# [lime]#START_TIME-END_TIME# [blue]#$/# [lime]#PAYER_INDEX# [black]#[# [blue]#c/# [lime]#MORE_CUSTOMER_INDICES# [black]#]# [black]#[# [blue]#com/# [lime]#COMMENTS# [black]#]#`

[NOTE]
====
* `SERVICE_TYPE` is the name of the service taken from the list in the application
* `START_TIME` and `END_TIME` follows the `HH 24-hour` format.
* `COMMENTS` can contain any text without slash (`/`).
* We allow the same person to book the same service for the same period of time. In short, we allow duplicate bookings.
* We allow a different person to book the same service for the same period od time as someone else already has.
====

Examples:

* `lc`, then `add-booking s/SWIMMING POOL :/12-14 $/2`
Adds a booking for service SWIMMING POOL, for the 2nd customer from the complete customer list, from 12:00 to 14:00 if the service is available.

.Example for the `above` command
image::ab1.png[width=""800""]

==== Listing all booked services: `list-bookings`,`lb`
Effect: Displays a booking list, which lists all the bookings made till now.
Format: `{[aqua]#list-bookings#/[aqua]#lb#}`

Example:

* `lb` +
Lists all bookings.

.Example for the `lb` command
image::lb.png[width=""800""]

==== Editing a booked service: `edit-booking`, `eb`

Effect: Edits the fields of a booking in the database. +
Format: `{[aqua]#edit-booking#/[aqua]#eb#} [lime]#INDEX# [black]#[# [blue]#s/# [lime]#SERVICE_NAME# [black]#]# [black]#[# [blue]#:/# [lime]#START_TIME-END_TIME# [black]#]# [black]#[# [blue]#p/# [lime]#PAYER_INDEX# [black]#]# [black]#[# [blue]#c/# [lime]#MORE_CUSTOMER_INDICES# [black]#]# [black]#[# [blue]#com/# [lime]#COMMENTS# [black]#]#`

[NOTE]
====
* Edits the booking at the specified index. The index refers to the index number shown in the displayed booking list. The index must be a positive integer.
* At least one of the optional fields must be provided. Otherwise, nothing will be changed.
* Existing values will be updated to the input values.
* When editing comments, the existing comments of the booking will be removed, i.e adding of comments is not cumulative.
====
[TIP]
You can remove all the booking's comments by typing `com/` without specifying any tags after it.

Examples:

* `lb`, then `eb 1 s/TRANSPORT`
Edits the service type of the 1st booking to be GYM.

.Example before the `eb 1 s/TRANSPORT` command
image::eb1.png[width=""800""]

.Example after the `eb 1 s/TRANSPORT` command
image::eb2.png[width=""800""]

* `lb`, then `edit-booking 2 :/14-15 com/`
Edits the timing of the 2nd booking to be 14:00 - 15:00 and clears all existing comments.

==== Deleting a booked service: `delete-booking`, `db`

Effect: Deletes a booking from the database.
Format: `{[aqua]#delete-booking#/[aqua]#db#} [lime]#INDEX#`

[NOTE]
====
* Deletes the booking at the specified index.
* The index refers to the index number shown in the displayed room service list. The index must be a positive integer.
====

Example:
 `lb`, then `delete-booking 2` +
Deletes the 2nd booking of the booking database

.Example before the `delete-booking 2` command
image::db1.png[width=""800""]

.Example after the `delete-booking 2` command
image::db2.png[width=""800""]

==== Clearing all bookings: `clear-bookings`, `cb`

Effect: Removes all service bookings from the database. +
Format: `{[aqua]#clear-bookings#/[aqua]#cb#}`

Example:

* `cb` +
Clears all bookings from the database.

.Example before the `cb` command
image::lb.png[width=""800""]

.Example after the `cb` command
image::lb.png[width=""800""]

==== Find a specific booking: `find-booking`, `fb`

Effect: Displays a booking list based on the filters given by the user. +
Format: `{[aqua]#find-booking#/[aqua]#fb#} [black]#[# [blue]#id/# [lime]#IDENTIFICATION_NO# [black]#]# [black]#[# [blue]#s/# [lime]#SERVICE_NAME# [black]#]# [black]#[# [blue]#:/# [lime]#START_TIME-END_TIME# [black]#]#`

[NOTE]
====
*  The searching is done in the whole booking list.
* If you just enter the command `fb`, it will display the entire booking list.
====

Example:

* `fb id/A0176884J` +
Returns all bookings for customer with identification number, A0176884J.

.Example before the `fb id/A0176884J` command
image::fb1.png[width=""800""]

* `fb id/A0176884J s/SPA` +
Returns all spa bookings for customer with identification number, A0176884j.

// end::booking-commands[]

// tag::generation-bill-commands[]
=== [underline]#Generate Bill commands#

[CAUTION]
====
All generate bill commands only display the bill. They don't make any change in the storage or the database. That is, the bill
isn't stored anywhere. So any changes in the database due to other commands while bill is being displayed doesn't affect it.
To see the new update in the bill, the command needs to be inputted again.
====
==== Generate bill for specific booking: `generate-bill-booking`, `gb-b`

Effect: Generates the bill for the specific booking of a customer +
Format: `{[aqua]#generate-bill-booking#/[aqua]#gb-b#} [lime]#INDEX# [black]#[# [blue]#s/# [lime]#SERVICE_NAME# [black]#]# [black]#[# [blue]#:/# [lime]#START_TIME - END_TIME# [black]#]#`

Example:

 * `lc`, then `generate-bill-booking 4` +
Returns the bill for all services booked by the customer at index 4.

.Example for the `generate-bill-booking 4` command
image::gbb1.png[width=""800""]
// end::generation-bill-commands[]

* `lc`, then `gb-b 1 s/SPA` +
Returns the bill for all spa services booked for the customer at index 1.

.Example for the `gb-b 1 s/SPA` command
image::gbb2.png[width=""800""]

// tag::generation-bill-commands2[]
==== Generate bill for specific reservation: `generate-bill-reservation`, `gb-r`

Effect: Generates the bill for the specific booking of a customer +
Format: `{[aqua]#generate-bill-reservation#/[aqua]#gb-r#} [lime]#INDEX# [black]#[# [blue]#r/# [lime]#ROOM_TYPE# [black]#]# [black]#[# [blue]#d/# [lime]#START_DATE - END_DATE# [black]#]#`

[CAUTION]
====
* If you enter `gb-r 2 d/4/6/2019 - 7/6/2019`, it calculates the bill for all reservations between 4th June to 7th June for customer at index 2. This does not include reservations which include the date 7th June.
====

Example:
// end::generation-bill-commands2[]

 * `lc`, then `generate-bill-reservation 1` +
Returns the bill for all rooms reserved by the customer at index 1.

.Example for the `generate-bill-reservation 1` command
image::gbr2.png[width=""800""]

// tag::generation-bill-commands3[]
* `lc`, then `gb-r 3 r/SHARING ROOM` +
Returns the bill for all sharing rooms reserved by the customer at index 3.

.Example for the `gb-r 3 r/SHARING  ROOM` command
image::gbr1.png[width=""800""]
// end::generation-bill-commands3[]

// tag::generation-bill-commands4[]
==== Generate customer's bill : `generate-bill-customer`, `gb-c`

Effect: Generates the bill for the customer based on his total room reservations and service bookings. +
Format: `{[aqua]#generate-bill-customer#/[aqua]#gb-c#} [lime]#INDEX#`

[TIP]
====
This command is a super set of all the other ""generate bill"" commands and can be used
to obtain the complete breakup for a customer.
====

Example:

*  `lc, then `generate-bill-customer 1` +
Returns the total bill (includes all bookings and reservations) for the customer at index 1.

.Example for the `generate-bill-customer 1` command
image::gbc1.png[width=""800""]
// end::generation-bill-commands4[]


=== [underline]#Show Statistics command# : `show-stats`, `ss`

Effect: Displays an individual window for statistics, including a text report and the charts.
Format: `{[aqua]#show-stats#/[aqua]#ss#} [black]#[# [lime]#INDICES_OF_ITEMS…# [black]#]#`

[NOTE]
====
* Simply `show-stats` or `ss` will display all stats items available.
* `INDICES_OF_ITEMS` should be integers between one and the largest index of the stats items.
====

Example:

* `ss` +
This displays all stats items available.

.Example for the `ss` command
image::ss.png[width=""800""]

* `ss 1 3` +
This displays the 1st and the 3rd stats items.

.Example for the `ss 1 3` command
image::ss-1-3.png[width=""800""]

=== [underline]#Switch tab command# : `switch-tab`, `st`

Effect: Switches the panel and the tab based on input by the user. +
Format: `{[aqua]#switch-tab#/[aqua]#st#} [lime]#PANEL_NUMBER# [lime]#TAB_NUMBER#`

[NOTE]
====
Panel Number 1: Consists of `Booking`, `Reservation` and `Bill` tabs. +
Panel Number 2: Consists of `Service Type` and `Room Type` tabs.
====

Example:

* `st 1 1` +
This will switch to the booking tab in the the first panel.

.Example for the `st 1 1` command
image::st-1-1.png[width=""800""]

* `st 2 1` +
This will switch to the service type tab in the second panel.

.Example for the `st 2 1` command
image::st-2-1.png[width=""800""]

=== [underline]#Select customer command# : `select`, `s`

Effect: Selects the customer whose index is specified. +
Format: `{[aqua]#select#/[aqua]#s#} [lime]#INDEX#`

Example:

* `s 1` +
Selects the customer at index 1.

.Example for the `s 11` command
image::s1.png[width=""800""]

=== [underline]#Listing entered commands# : `history`,`hs`

Effect: Lists all the commands that you have entered in reverse chronological order. +
Format: `{[aqua]#history#/[aqua]#hs#}`

.Example for the `clear-all` command
image::history-command.png[width=""800""]

[NOTE]
====
Pressing the kbd:[&uarr;] and kbd:[&darr;] arrows will display the previous and next input respectively in the command box.
====

// tag::undoredo[]
=== [underline]#Undoing previous command# : `undo`,`u`

Effect: Restores the address book to the state before the previous _undoable_ command was executed. +
Format: `{[aqua]#undo#/[aqua]#u#}`

[NOTE]
====
Undoable commands: those commands that modify HMS's content (`addc`, `deletecustomer`, `editc`, etc.).
====

Examples:

* `delete-customer 1` +
`lc` +
`undo` (adds back the deleted customer) +

.Example for the `undo`command
image::undo.png[width=""800""]

* `lc` +
`undo` +
The `undo` command fails as there are no undoable commands executed previously.

* `delete-customer 1` +
`clear-all` +
`undo` (adds back all cleared entries) +
`undo` (adds back the previously deleted customer) +

=== [underline]#Redoing the previously undone command# : `redo`,`r`

Effect: Reverses the most recent `undo` command. +
Format: `{[aqua]#redo#/[aqua]#r#}`

Examples:

* `delete-customer 1` +
`undo` (adds back the deleted customer) +
`redo` (deletes customer at index 1 again) +

.Example for the `undo` and `redo` command
image::undo-redo.png[width=""800""]

* `delete-customer 1` +
`redo` +
The `redo` command fails as there are no `undo` commands executed previously.

* `delete-customer 1` +
`clear` +
`undo` (adds back all cleared entries) +
`undo` (adds back the previously deleted customer) +
`redo` (deletes customer at index 1 again) +
`redo` (clears all remaining entries again) +
// end::undoredo[]

=== [underline]#Clearing all entries# : `clear-hms`, `clear-all`

Effect: Clears all entries from the database. +
Format: `{[aqua]#clear-hms#/[aqua]#clear-all#}`

.Example for the `clear-all` command
image::clear-all-command.png[width=""800""]


=== [underline]#Exiting the program# : `exit`,`ex`

Effect: Exits the program. +
Format: `{[aqua]#exit#/[aqua]#ex#}`

.The `exit` command
image::exit-command.png[width=""800""]

=== [underline]#Automatic tab switching#

The tab will be switched automatically to show the content.

==== [underline]#Service Booking#
All service booking related commands will switch tab to the one for Booking and the one for Service Type. +

Example:

*  `lb` +
All bookings will be shown and the tab will also be switched

.Example for the automatic tab switching for `lb` command before executing
image::atp_forbooking1.png[width=""800""]

.Example for the automatic tab switching for `lb` command after executing
image::atp_forbooking2.png[width=""800""]

==== [underline]#Room Reservation#
All room reservation related commands will switch tab to the one for Reservation and the one for Room Type. +

Example:

*  `lr` +
All reservations will be shown and the tab will also be switched.

.Example for the automatic tab switching for `lr` command before executing
image::atp_forreservation1.png[width=""800""]

.Example for the automatic tab switching for `lr` command after executing
image::atp_forreservation2.png[width=""800""]

==== [underline]#Bill#
All bill related commands will switch tab to the one for Bill. +

Example:

*  `gb-c 1` +
The bill be generated and the tab will also be switched.

.Example for the automatic tab switching for `gb-c 1` command before executing
image::atp_forbill1.png[width=""800""]

.Example for the automatic tab switching for `gb-c 1` command after executing
image::atp_forbill2.png[width=""800""]

=== [underline]#Automatic panel scrolling#
==== [underline]#Service Booking#
The customer panel will be scrolled automatically to show the newly added item.

.Example for the automatic panel scrolling for `ac n/Tom Brown p/12442512 e/tom@brown.com id/G112342H` command before executing
image::aps_forcustomer1.png[width=""800""]

.Example for the automatic panel scrolling for `ac n/Tom Brown p/12442512 e/tom@brown.com id/G112342H` command after executing
image::aps_forcustomer2.png[width=""800""]

==== [underline]#Service Booking#
The booking panel will be scrolled automatically to show the newly added item.

.Example for the automatic tab switching for `ab s/TUTORIAL :/10-11 $/1` command before executing
image::aps_forbooking1.png[width=""800""]

.Example for the automatic tab switching for `ab s/TUTORIAL :/10-11 $/1` command after executing
image::aps_forbooking2.png[width=""800""]

==== [underline]#Room Reservation#
The reservation panel will be scrolled automatically to show the newly added item.

.Example for the automatic panel scrolling for `ar r/DOUBLE DOUBLE ROOM d/16/04/2019-17/04/2019 $/3` command before executing
image::aps_forreservation1.png[width=""800""]

.Example for the automatic panel scrolling for `ar r/DOUBLE DOUBLE ROOM d/16/04/2019-17/04/2019 $/3` command after executing
image::aps_forreservation2.png[width=""800""]

=== [underline]#Filtering by clicking#
==== [underline]#Service Booking#
Click on a service type and the booking list will be filtered by the clicked service type.

.Example for booking filtering before clicking
image::fbc_forbooking1.png[width=""800""]

.Example for booking filtering after clicking
image::fbc_forbooking2.png[width=""800""]

==== [underline]#Room Reservation#
Click on a service type and the booking list will be filtered by the clicked room type.

.Example for reservation filtering before clicking
image::fbc_forbooking1.png[width=""800""]

.Example for reservation filtering after clicking
image::fbc_forbooking2.png[width=""800""]

=== [underline]#Saving the data#

The HMS+ data file is saved in the hard disk automatically after any command that changes the data. +
There is no need to save manually.

== Prefix List

=== Customer
* [underline]*Name* +
  _Prefix_:: `n/` +
  _Validation_:: Name should adhere to following constraints:

     1: It cannot be blank.
     2: It should only contain alphanumeric characters and space.

       _Example_:: [blue]#n/# Tejas Bhuwania

   * [underline]*Phone* +
    _Prefix_:: `p/` +
    _Validation_:: Phone should adhere to following constraints:

    1: It should contain only digits.
    2: It should be at least 3 digits long.

    _Example_:: [blue]#p/# 81424394
// tag::prefixlist[]
    * [underline]*Email* +
      _Prefix_:: `e/` +
      _Validation_:: Email should  adhere to the following constraints:

                    1: Email should be of the format local-part@domain.
                    2: The local-part should only contain alphanumeric characters and these special characters, excluding the parentheses, (!#$%&'*+/=?`{|}~^.-).
                    3: This is followed by a '@' and then a domain name. The domain name must:
                        - be at least 2 characters long
                        - start and end with alphanumeric characters
                        - consists alphanumeric characters, a period or hyphen for characters in between

     _Example_:: [blue]#e/# tejasbhuwania2855@gmail.com

    * [underline]*Identification Number* +
      _Prefix_:: `id/` +
       _Validation_:: Identification Number should adhere to following constraints:

        1: It should contain only digits and uppercase alphabetical letters.
        2: It should be at least 7 digits long and maximum 10 digits long

      _Example_:: [blue]#id/# Z4264321

    * [underline]*Date of Birth* +
      _Prefix_:: `dob/` +
       _Validation_:: Date of Birth should adhere to the following constraints:

          1: Date of birth should not exceed the current date.
          2: Date of birth should be of the format: DD/MM/YYYY.

      _Example_:: [blue]#dob/# 28/05/1999
// end::prefixlist[]

* [underline]*Address* +
  _Prefix_:: `a/` +
  _Validation_:: Address has no constraints.

    _Example_:: [blue]#a/# 311, Ali Amar Avenue

    * [underline]*Tag* +
      _Prefix_:: `t/` +
      _Validation_:: Tag should adhere to following constraints:

        1: Tags should be alphanumeric only.

        _Example_:: [blue]#t/# friend

=== Only Service Type

* [underline]*Operational Hours of Service* +
  _Prefix_:: `:/` +
  _Validation_:: Operational Hours of Service should adhere to following constraints:

     1: It should be between 0 - 23.
     2: It should be of the format: HH - HH.


       _Example_:: [blue]#:/# 10-22

=== Both Service Type and Room Type

* [underline]*Name of Service or Room Type* +
  _Prefix_:: `n/` +
  _Validation_:: Name should adhere to following constraints:

     1: It cannot be blank.
     2: It should only contain alphanumeric characters and space.
     3: It can be maximum 20 in length.

       _Example_:: [blue]#n/# DOUBLE ROOM

* [underline]*Rate of Service or Room Type* +
 _Prefix_:: `rate/` +
 _Validation_:: Rate should adhere to following constraints:

  1: It should be positive.

  _Example_:: [blue]#rate/# 700.0

* [underline]*Capacity of Service or Number of Rooms* +
 _Prefix_:: `cap/` +
 _Validation_:: Capacity should adhere to following constraints:

  1: It should be positive.

  _Example_:: [blue]#rate/# 200

=== Only Service Booking

* [underline]*Service Type* +
  _Prefix_:: `s/` +
  _Validation_:: Service Type should adhere to following constraints:

     1: It should be a defined service type already present in the list.

     _Example_:: [blue]#s/# GYM

* [underline]*Timing of Service* +
  _Prefix_:: `:/` +
  _Validation_:: Timing of Service adheres to following constraints:

    1: The service timing should be within the operating hours.
    2: If service type is full during that time, it returns an error message.
    3: It should be of the format: HH - HH.

    _Example_:: [blue]#:/# 08 - 10

=== Only Room Reservation

* [underline]*Room Type* +
  _Prefix_:: `r/` +
   _Validation_:: Room Type should adhere to following constraints:

   1: It should be a defined room type already present in the list.

   _Example_:: [blue]#r/# SINGLE ROOM

* [underline]*Date of Reservation* +
  _Prefix_:: `d/` +
  _Validation_:: Date of Reservation adheres to the following constraints:

    1: If room type is full during those dates, it returns an error message.
    2: It should be of the format: DD/MM/YYYY - DD/MM/YYYY.
    3: It can only be from current date to one year after current date.

    _Example_:: [blue]#d/# 12/10/2019 - 14/12/2019

=== Both Service Booking and Room Reservation

* [underline]*Payer of Reservation or Service* +
  _Prefix_:: `$/` +
  _Validation_:: Payer of Reservation should adhere to following constraints:

   1: The index number should be valid.

   _Example_:: [blue]#$/# 1

* [underline]*Customers involved in Reservation or Service* +
  _Prefix_:: `c/` +
  _Validation_:: Customers involved in Reservation or Service should adhere to following constraints:

   1: The index number should be valid.

   _Example_:: [blue]#c/# 1

* [underline]*Comment for Reservation or Service* +
  _Prefix_:: `com/` +
  _Validation_:: Comment for Reservation or Service  should adhere to following constraints:

   1: It shouldn't contain (/).

   _Example_:: [blue]#com/# Please turn AC on.


== Command Summary

* *Help* : `{help/hp}`
* *Add Customer* : `{add-customer/ac} n/NAME p/PHONE_NUMBER e/EMAIL id/IDENTIFICATION_NO [a/ADDRESS] [dob/DATE_OF_BIRTH] [t/TAG]…`
* *List Customers* : `{list-customers/lc}`
* *Edit Customer* : `{edit-customer/ec} INDEX [n/NAME] [p/PHONE] [e/EMAIL] [id/IDENTIFICATION_NO] [a/ADDRESS] [t/TAG]…`
* *Find Customer by name* : `{find-name/fn} KEYWORD [MORE_KEYWORDS]`
* *Delete Customer* : `{delete-customer/dc} INDEX`
* *Add Room Type* : `{add-room-type/art} n/ROOM_TYPE rate/RATE cap/NUMBER_OF_ROOM`
* *Delete Room Type* : `{delete-room-type/drt} INDEX`
* *Edit Room Type* : `{edit-room-type/ert} n/ROOM_TYPE rate/RATE cap/NUMBER_OF_ROOM`
* *Reserve room* : `{add-reservation/ar} r/ROOM_TYPE d/START_DATE-END_DATE $/PAYER_INDEX [c/MORE_CUSTOMER_INDICIES…] [com/COMMENTS]`
* *List room reservations* : `{list-reservations/lr}`
* *Edit room reservations* : `{edit-reservation/er} INDEX [s/SERVICE_NAME] [:/START_TIME - END_TIME] [p/PAYER_INDEX] [c/MORE_CUSTOMER_INDICES] [com/COMMENTS]`
* *Delete room reservation* : `{delete-reservation/dr} INDEX`
* *Add Service Type* : `{add-service-type/ast} n/SERVICE_NAME rate/RATE cap/CAPACITY_OF_SERVICE:/OPERATIONAL_HOURS`
* *Delete Service Type* : `{delete-service-type/dst} INDEX`
* *Edit Service Type* : `{edit-service-type/est} n/SERVICE_NAME rate/RATE cap/CAPACITY_OF_SERVICE:/OPERATIONAL_HOURS`
* *Book services of hotel* : `{add-booking/ab} `{add-booking/ab} s/SERVICE_NAME :/START_TIME-END_TIME $/PAYER_INDEX [c/MORE_CUSTOMER_INDICES] [com/COMMENTS]`
* *List services already booked* : `{list-bookings/lb}`
* *Edit services already booked* : `{edit-booking/eb} INDEX [s/SERVICE_NAME] [:/START_TIME# - END_TIME] [p/PAYER_INDEX] [c/MORE_CUSTOMER_INDICES] [com/COMMENTS]`
* *Delete service already booked* : `{delete-booking/db} INDEX`
* *Finding a specific booking* : `{find-booking/fb} [id/IDENTIFICATION_NO] [s/SERVICE_NAME] [:/START_TIME-END_TIME]`
* *Finding a specific reservation* : `{find-reservation/fr} [id/IDENTIFICATION_NO] [r/ROOM_TYPE]` [d/START_DATE-END_DATE]`
* *Generate bill for specific booking* : `{generate-bill-booking/gb-b} INDEX [s/SERVICE_NAME] [:/START_TIME-END_TIME]`
* *Generate bill for specific reservation* : `{generate-bill-reservation/gb-r} INDEX [r/ROOM_TYPE]` [d/START_DATE-END_DATE]`
* *Generate bill for customer* : `{generate-bill-customer/gb-c} INDEX`
* *Switch tab* : `{switch-tab/st} PANEL_NUMBER TAB_NUMBER`
* *Select customer* "" `{select/s}` INDEX
* *History* : `{history/hs}`
* *Undo* : `{undo/u}`
* *Redo* : `{redo/r}`
* *Clear hotel management system database* : `{clear-hms/clear-all}`
* *Clear room reservations* : `{clear-reservations/cr}`
* *Clear booked services* : `{clear-bookings/cb}`
* *Clear room types* : `{clear-room-type/crt}`
* *Clear service types* : `{clear-service-type/cst}`
* *Exit* : `{exit/ex}`
",12482,True,2641.997986964405,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
////
= Using OpenID Connect (OIDC) to Protect Web Applications using Authorization Code Flow.

include::./attributes.adoc[]
:toc:

This guide demonstrates how to use Quarkus OpenID Connect (OIDC) Extension to protect your Quarkus HTTP endpoints using OpenId Connect Authorization Code Flow supported by OpenId Connect compliant Authorization Servers such as https://www.keycloak.org/about.html[Keycloak].

The extension allows to easily authenticate the users of your web application by redirecting them to the OpenID Connect Provider (e.g.: Keycloak) to login and, once the authentication is complete, return them back with the code confirming the successful authentication. The extension will request ID and access tokens from the OpenID Connect Provider using an authorization code grant and verify these tokens in order to authorize an access to the application.

Please read the link:security-openid-connect[Using OpenID Connect to Protect Service Applications] guide if you need to protect your applications using Bearer Token Authorization.

Please read the link:security-openid-connect-multitenancy[Using OpenID Connect Multi-Tenancy] guide how to support multiple tenants.

== Prerequisites

To complete this guide, you need:

* less than 15 minutes
* an IDE
* JDK 11+ installed with `JAVA_HOME` configured appropriately
* Apache Maven {maven-version}
* https://stedolan.github.io/jq/[jq tool]
* Docker

== Architecture

In this example, we build a very simple web application with a single page:

* `/index.html`

This page is protected and can only be accessed by authenticated users.

== 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].

The solution is located in the `security-openid-connect-web-authentication-quickstart` {quickstarts-tree-url}/security-openid-connect-web-authentication-quickstart[directory].

== Creating the Maven Project

First, we need a new project. Create a new project with the following command:

[source,bash,subs=attributes+]
----
mvn io.quarkus.platform:quarkus-maven-plugin:{quarkus-version}:create \\
    -DprojectGroupId=org.acme \\
    -DprojectArtifactId=security-openid-connect-web-authentication-quickstart \\
    -Dextensions=""resteasy,oidc"" \\
    -DnoExamples
cd security-openid-connect-web-authentication-quickstart
----

If you already have your Quarkus project configured, you can add the `oidc` extension
to your project by running the following command in your project base directory:

[source,bash]
----
./mvnw quarkus:add-extension -Dextensions=""oidc""
----

This will add the following to your `pom.xml`:

[source,xml]
----
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-oidc</artifactId>
</dependency>
----

== Writing the application

Let's write a simple JAX-RS resource which has all the tokens returned in the authorization code grant response injected:

[source,java]
----
package org.acme.security.openid.connect.web.authentication;

import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;

import org.eclipse.microprofile.jwt.JsonWebToken;

import io.quarkus.oidc.IdToken;
import io.quarkus.oidc.RefreshToken;

@Path(""/tokens"")
public class TokenResource {

    /**
     * Injection point for the ID Token issued by the OpenID Connect Provider
     */
    @Inject
    @IdToken
    JsonWebToken idToken;

    /**
     * Injection point for the Access Token issued by the OpenID Connect Provider
     */
    @Inject
    JsonWebToken accessToken;

    /**
     * Injection point for the Refresh Token issued by the OpenID Connect Provider
     */
    @Inject
    RefreshToken refreshToken;

    /**
     * Returns the tokens available to the application. This endpoint exists only for demonstration purposes, you should not
     * expose these tokens in a real application.
     *
     * @return a map containing the tokens available to the application
     */
    @GET
    public String getTokens() {
        StringBuilder response = new StringBuilder().append(""<html>"")
                .append(""<body>"")
                .append(""<ul>"");

        Object userName = this.idToken.getClaim(""preferred_username"");

        if (userName != null) {
            response.append(""<li>username: "").append(userName.toString()).append(""</li>"");
        }

        Object scopes = this.accessToken.getClaim(""scope"");

        if (scopes != null) {
            response.append(""<li>scopes: "").append(scopes.toString()).append(""</li>"");
        }

        response.append(""<li>refresh_token: "").append(refreshToken.getToken() != null).append(""</li>"");

        return response.append(""</ul>"").append(""</body>"").append(""</html>"").toString();
    }
}
----

This endpoint has ID, access and refresh tokens injected. It returns a `preferred_username` claim from the ID token, a `scope` claim from the access token and also a refresh token availability status.

Note that you do not have to inject the tokens - it is only required if the endpoint needs to use the ID token to interact with the currently authenticated user or use the access token to access a downstream service on behalf of this user.

Please see <<access_id_and_access_tokens,Access ID and Access Tokens>> section below for more information.

== Configuring the application

The OpenID Connect extension allows you to define the configuration using the `application.properties` file which should be located at the `src/main/resources` directory.

=== Configuring using the application.properties file

[source,properties]
----
quarkus.oidc.auth-server-url=http://localhost:8180/auth/realms/quarkus
quarkus.oidc.client-id=frontend
quarkus.oidc.application-type=web-app
quarkus.http.auth.permission.authenticated.paths=/*
quarkus.http.auth.permission.authenticated.policy=authenticated
----

This is the simplest configuration you can have when enabling authentication to your application. 

The `quarkus.oidc.client-id` property references the `client_id` issued by the OpenID Connect Provider and, in this case, the application is a public client (no client secret is defined).

The `quarkus.oidc.application-type` property is set to `web-app` in order to tell Quarkus that you want to enable the OpenID Connect Authorization Code Flow, so that your users are redirected to the OpenID Connect Provider to authenticate.

For last, the `quarkus.http.auth.permission.authenticated` permission is set to tell Quarkus about the paths you want to protect. In this case,
all paths are being protected by a policy that ensures that only `authenticated` users are allowed to access. For more details check link:security-authorization[Security Authorization Guide].

=== Configuring CORS

If you plan to consume this application from another application running on a different domain, you will need to configure CORS (Cross-Origin Resource Sharing). Please read the link:http-reference#cors-filter[HTTP CORS documentation] for more details.

== Starting and Configuring the Keycloak Server

To start a Keycloak Server you can use Docker and just run the following command:

[source,bash,subs=attributes+]
----
docker run --name keycloak -e KEYCLOAK_USER=admin -e KEYCLOAK_PASSWORD=admin -p 8180:8080 {keycloak-docker-image}
----

You should be able to access your Keycloak Server at http://localhost:8180/auth[localhost:8180/auth].

Log in as the `admin` user to access the Keycloak Administration Console. Username should be `admin` and password `admin`.

Import the {quickstarts-tree-url}/security-openid-connect-web-authentication-quickstart/config/quarkus-realm.json[realm configuration file] to create a new realm. For more details, see the Keycloak documentation about how to https://www.keycloak.org/docs/latest/server_admin/index.html#_create-realm[create a new realm].

== Running and Using the Application

=== Running in Developer Mode

To run the microservice in dev mode, use `./mvnw clean compile quarkus:dev`.

=== Running in JVM Mode

When you're done playing with ""dev-mode"" you can run it as a standard Java application.

First compile it:

[source,bash]
----
./mvnw package
----

Then run it:

[source,bash]
----
java -jar target/quarkus-app/quarkus-run.jar
----

=== Running in Native Mode

This same demo can be compiled into native code: no modifications required.

This implies that you no longer need to install a JVM on your
production environment, as the runtime technology is included in
the produced binary, and optimized to run with minimal resource overhead.

Compilation will take a bit longer, so this step is disabled by default;
let's build again by enabling the `native` profile:

[source,bash]
----
./mvnw package -Pnative
----

After getting a cup of coffee, you'll be able to run this binary directly:

[source,bash]
----
./target/security-openid-connect-web-authentication-quickstart-runner
----

== Testing the Application

To test the application, you should open your browser and access the following URL:

* http://localhost:8080[http://localhost:8080]

If everything is working as expected, you should be redirected to the Keycloak server to authenticate.

In order to authenticate to the application you should type the following credentials when at the Keycloak login page:

* Username: *alice*
* Password: *alice*

After clicking the `Login` button you should be redirected back to the application.

== Redirection

When the user is redirected to the OpenID Connect Provider to authenticate, the redirect URL includes a `redirect_uri` query parameter which indicates to the Provider where the user has to be redirected to once the authentication has been completed.

Quarkus will set this parameter to the current request URL by default. For example, if the user is trying to access a Quarkus service endpoint at `http://localhost:8080/service/1` then the `redirect_uri` parameter will be set to `http://localhost:8080/service/1`. Similarly, if the request URL is `http://localhost:8080/service/2` then the `redirect_uri` parameter will be set to `http://localhost:8080/service/2`, etc.

OpenID Connect Providers may be configured to require the `redirect_uri` parameter to have the same value (eg. `http://localhost:8080/service/callback`) for all the redirect URLs.
In such cases a `quarkus.oidc.authentication.redirect-path` property has to be set, for example, `quarkus.oidc.authentication.redirect-path=/service/callback`, and Quarkus will set the `redirect_uri` parameter to an absolute URL such as `http://localhost:8080/service/callback` which will be the same regardless of the current request URL.

If `quarkus.oidc.authentication.redirect-path` is set but the original request URL has to be restored after the user has been redirected back to a callback URL such as `http://localhost:8080/service/callback` then a `quarkus.oidc.authentication.restore-path-after-redirect` property has to be set to `true` which will restore the request URL such as `http://localhost:8080/service/1`, etc.

[[oidc-cookies]]
== Dealing with Cookies

The OIDC adapter uses cookies to keep the session, code flow and post logout state.

`quarkus.oidc.authentication.cookie-path` property is used to ensure the cookies are visible especially when you access the protected resources with overlapping or different roots, for example: 

* `/index.html` and `/web-app/service`
* `/web-app/service1` and `/web-app/service2`
* `/web-app1/service` and `/web-app2/service` 

`quarkus.oidc.authentication.cookie-path` is set to `/` by default but can be narrowed to the more specific root path such as `/web-app`.

You can also set a `quarkus.oidc.authentication.cookie-path-header` property if the cookie path needs to be set dynamically.
For example, setting `quarkus.oidc.authentication.cookie-path-header=X-Forwarded-Prefix` means that the value of HTTP `X-Forwarded-Prefix` header will be used to set a cookie path.

If `quarkus.oidc.authentication.cookie-path-header` is set but no configured HTTP header is available in the current request then the `quarkus.oidc.authentication.cookie-path` will be checked.

If your application is deployed across multiple domains, make sure to set a `quarkus.oidc.authentication.cookie-domain` property for the session cookie be visible to all protected Quarkus services, for example, if you have 2 services deployed at:

* https://whatever.wherever.company.net/
* https://another.address.company.net/

then the `quarkus.oidc.authentication.cookie-domain` property must be set to `company.net`.

== Logout

By default the logout is based on the expiration time of the ID Token issued by the OpenID Connect Provider. When the ID Token expires, the current user session at the Quarkus endpoint is invalidated and the user is redirected to the OpenID Connect Provider again to authenticate. If the session at the OpenID Connect Provider is still active, users are automatically re-authenticated without having to provide their credentials again.

The current user session may be automatically extended by enabling a `quarkus.oidc.token.refresh-expired` property. If it is set to `true` then when the current ID Token expires a Refresh Token Grant will be used to refresh ID Token as well as Access and Refresh Tokens.

=== User-Initiated Logout

Users can request a logout by sending a request to the Quarkus endpoint logout path set with a `quarkus.oidc.logout.path` property.
For example, if the endpoint address is `https://application.com/webapp` and the `quarkus.oidc.logout.path` is set to ""/logout"" then the logout request has to be sent to `https://application.com/webapp/logout`.

This logout request will start an https://openid.net/specs/openid-connect-session-1_0.html#RPLogout[RP-Initiated Logout] and the user will be redirected to the OpenID Connect Provider to logout where a user may be asked to confirm the logout is indeed intended.

The user will be returned to the endpoint post logout page once the logout has been completed if the `quarkus.oidc.logout.post-logout-path` property is set. For example, if the endpoint address is `https://application.com/webapp` and the `quarkus.oidc.logout.post-logout-path` is set to ""/signin"" then the user will be returned to `https://application.com/webapp/signin` (note this URI must be registered as a valid `post_logout_redirect_uri` in the OpenID Connect Provider).

If the `quarkus.oidc.logout.post-logout-path` is set then a `q_post_logout` cookie will be created and a matching `state` query parameter will be added to the logout redirect URI and the OpenID Connect Provider will return this `state` once the logout has been completed. It is recommended for the Quarkus `web-app` applications to check that a `state` query parameter matches the value of the `q_post_logout` cookie which can be done for example in a JAX-RS filter.

Note that a cookie name will vary when using link:security-openid-connect-multitenancy[OpenID Connect Multi-Tenancy]. For example, it will be named `q_post_logout_tenant_1` for a tenant with a `tenant_1` id, etc.

Here is an example of how to configure an RP initiated logout flow:

[source,properties]
----
quarkus.oidc.auth-server-url=http://localhost:8180/auth/realms/quarkus
quarkus.oidc.client-id=frontend
quarkus.oidc.application-type=web-app

quarkus.oidc.tenant-logout.logout.path=/logout
quarkus.oidc.tenant-logout.logout.post-logout-path=/postlogout

# Only the authenticated users can initiate a logout:
quarkus.http.auth.permission.authenticated.paths=/logout
quarkus.http.auth.permission.authenticated.policy=authenticated

# Logged out users should be returned to the /welcome.html site which will offer an option to re-login:
quarkus.http.auth.permission.authenticated.paths=/welcome.html
quarkus.http.auth.permission.authenticated.policy=permit
----

You may also need to set `quarkus.oidc.authentication.cookie-path` to a path value common to all of the application resources which is `/` in this example.
See <<oidc-cookies, Dealing with Cookies>> for more information.

[[access_id_and_access_tokens]]
== Accessing ID and Access Tokens

OIDC Code Authentication Mechanism acquires three tokens during the authorization code flow: https://openid.net/specs/openid-connect-core-1_0.html#IDToken[IDToken], Access Token and Refresh Token.

ID Token is always a JWT token and is used to represent a user authentication with the JWT claims.
One can access ID Token claims by injecting `JsonWebToken` with an `IdToken` qualifier:

[source, java]
----
import javax.inject.Inject;
import org.eclipse.microprofile.jwt.JsonWebToken;
import io.quarkus.oidc.IdToken;
import io.quarkus.security.Authenticated;

@Path(""/web-app"")
@Authenticated
public class ProtectedResource {

    @Inject
    @IdToken
    JsonWebToken idToken;

    @GET
    public String getUserName() {
        return idToken.getName();
    }
}
----

Access Token is usually used by the OIDC `web-app` application to access other endpoints on behalf of the currently logged in user. The raw access token can be accessed as follows:

[source, java]
----
import javax.inject.Inject;
import org.eclipse.microprofile.jwt.JsonWebToken;
import io.quarkus.oidc.AccessTokenCredential;
import io.quarkus.security.Authenticated;

@Path(""/web-app"")
@Authenticated
public class ProtectedResource {

    @Inject
    JsonWebToken accessToken;

    // or
    // @Inject
    // AccessTokenCredential accessTokenCredential;

    @GET
    public String getReservationOnBehalfOfUser() {
        String rawAccessToken = accessToken.getRawToken();
        //or
        //String rawAccessToken = accessTokenCredential.getToken();

        // Use the raw access token to access a remote endpoint
        return getReservationfromRemoteEndpoint(rawAccesstoken);
    }
}
----

Note that `AccessTokenCredential` will have to be used if the Access Token issued to the Quarkus `web-app` application is opaque (binary) and can not be parsed to `JsonWebToken`.

Injection of the `JsonWebToken` and `AccessTokenCredential` is supported in both `@RequestScoped` and `@ApplicationScoped` contexts.

RefreshToken is only used to refresh the current ID and access tokens as part of its link:#session_management[session management] process.

[[user-info]]
== User Info

If IdToken does not provide enough information about the currently authenticated user then you can set a `quarkus.oidc.user-info-required=true` property for a https://openid.net/specs/openid-connect-core-1_0.html#UserInfo[UserInfo] JSON object from the OIDC userinfo endpoint to be requested.

A request will be sent to the OpenId Provider UserInfo endpoint using the access token returned with the authorization code grant response and an `io.quarkus.oidc.UserInfo` (a simple `javax.json.JsonObject` wrapper) object will be created. `io.quarkus.oidc.UserInfo` can be either injected or accessed as a SecurityIdentity `userinfo` attribute.

[[config-metadata]]
== Configuration Metadata

The current tenant's discovered link:https://openid.net/specs/openid-connect-discovery-1_0.html#ProviderMetadata[OpenId Connect Configuration Metadata] is represented by `io.quarkus.oidc.OidcConfigurationMetadata` and can be either injected or accessed as a `SecurityIdentity` `configuration-metadata` attribute.

The default tenant's `OidcConfigurationMetadata` is injected if the endpoint is public.

[[token-claims-roles]]
== Token Claims And SecurityIdentity Roles

The way the roles are mapped to the SecurityIdentity roles from the verified tokens is identical to how it is done for the link:security-openid-connect#token-claims-and-securityidentity-roles[bearer tokens] with the only difference being is that https://openid.net/specs/openid-connect-core-1_0.html#IDToken[ID Token] is used as a source of the roles by default.

Note if you use Keycloak then you should set a Microprofile JWT client scope for ID token to contain a `groups` claim, please see the https://www.keycloak.org/docs/latest/server_admin/#protocol[Keycloak Server Administration Guide] for more information.

If only the access token contains the roles and this access token is not meant to be propagated to the downstream endpoints then set `quarkus.oidc.roles.source=accesstoken`.

If UserInfo is the source of the roles then set `quarkus.oidc.authentication.user-info-required=true` and `quarkus.oidc.roles.source=userinfo`, and if needed, `quarkus.oidc.roles.role-claim-path`.

Additionally a custom `SecurityIdentityAugmentor` can also be used to add the roles as documented link:security#security-identity-customization[here].

[[token-verification-introspection]]
== Token Verification And Introspection

Please see link:security-openid-connect#token-verification-introspection for details about how the tokens are verified and introspected.

Note that in case of `web-app` applications only `IdToken` is verified by default since the access token is not used by default to access the current Quarkus `web-app` endpoint and instead meant to be propagated to the services expecting this access token, for example, to the OpenId Connect Provider's UserInfo endpoint, etc. However if you expect the access token to contain the roles required to access the current Quarkus endpoint (`quarkus.oidc.roles.source=accesstoken`) then it will also be verified.

[[token-introspection-userinfo-cache]]
== Token Introspection and UserInfo Cache

Code flow access tokens are not introspected unless they are expected to be the source of roles but will be used to get `UserInfo`. So there will be one or two remote calls with the code flow access token, if the token introspection and/or `UserInfo` are required.

Please see link:security-openid-connect#token-introspection-userinfo-cache for more information about using a default token cache or registering a custom cache implementation.

[[session-management]]
== Session Management

If you have a link:security-openid-connect#single-page-applications[Single Page Application for Service Applications] where your OpenId Connect Provider script such as `keycloak.js` is managing an authoriization code flow then that script will also control the SPA authentication session lifespan.

If you work with a Quarkus OIDC `web-app` application then it is Quarkus OIDC Code Authentication mechanism which is managing the user session lifespan.

The session age is calculated by adding the lifespan value of the current IDToken and the values of the `quarkus.oidc.authentication.session-age-extension` and `quarkus.oidc.token.lifespan-grace` properties. Of the last two properties only `quarkus.oidc.authentication.session-age-extension` should be used to significantly extend the session lifespan if required since `quarkus.oidc.token.lifespan-grace` is only meant for taking some small clock skews into consideration.

When the currently authenticated user returns to the protected Quarkus endpoint and the ID token associated with the session cookie has expired then, by default, the user will be auto-redirected to the OIDC Authorization endpoint to re-authenticate. Most likely the OIDC provider will challenge the user again though not necessarily if the session between the user and this OIDC provider is still active which may happen if it is configured to last longer than the ID token.

If the `quarkus.oidc.token.refresh-expired` then the expired ID token (as well as the access token) will be refreshed using the refresh token returned with the authorization code grant response. This refresh token may also be recycled (refreshed) itself as part of this process. As a result the new session cookie will be created and the session will be extended.

Note, `quarkus.oidc.authentication.session-age-extension` can be important when dealing with expired ID tokens, when the user is not very active. In such cases, if the ID token expires, then the session cookie may not be returned back to the Quarkus endpoint during the next user request and Quarkus will assume it is the first authentication request. Therefore using `quarkus.oidc.authentication.session-age-extension` is important if you need to have even the expired ID tokens refreshed.

You can also complement refreshing the expired ID tokens by proactively refreshing the valid ID tokens which are about to be expired within the `quarkus.oidc.token.refresh-token-time-skew` value. If, during the current user request, it is calculated that the current ID token will expire within this `quarkus.oidc.token.refresh-token-time-skew` then it will be refreshed and the new session cookie will be created. This property should be set to a value which is less than the ID token lifespan; the closer it is to this lifespan value the more often the ID token will be refreshed.

You can have this process further optimized by having a simple JavaScript function periodically emulating the user activity by pinging your Quarkus endpoint thus minimizing the window during which the user may have to be re-authenticated.

Note this user session can not be extended forever - the returning user with the expired ID token will have to re-authenticate at the OIDC provider endpoint once the refresh token has expired.

=== TokenStateManager

OIDC `CodeAuthenticationMechanism` is using the default `io.quarkus.oidc.TokenStateManager` interface implementation to keep the ID, access and refresh tokens returned in the authorization code or refresh grant responses in a session cookie. It makes Quarkus OIDC endpoints completely stateless.

Note that some endpoints do not require the access token. An access token is only required if the endpoint needs to retrieve `UserInfo` or access the downstream service with this access token or use the roles associated with the access token (the roles in the ID token are checked by default). In such cases you can set either `quarkus.oidc.token-state-manager.strategy=id-refresh-token` (keep ID and refresh tokens only) or `quarkus.oidc.token-state-manager.strategy=id-token` (keep ID token only).

If the ID, access and refresh tokens are JWT tokens then combining all of them (if the strategy is the default `keep-all-tokens`) or only ID and refresh tokens (if the strategy is `id-refresh-token`) may produce a session cookie value larger than 4KB and the browsers may not be able to keep this cookie.
In such cases, you can use `quarkus.oidc.token-state-manager.split-tokens=true` to have a unique session token per each of these tokens.

Register your own `io.quarkus.oidc.TokenStateManager' implementation as an `@ApplicationScoped` CDI bean if you need to customize the way the tokens are associated with the session cookie. For example, you may want to keep the tokens in a database and have only a database pointer stored in a session cookie. Note though that it may present some challenges in making the tokens available across multiple microservices nodes.

Here is a simple example:

[source, java]
----
package io.quarkus.oidc.test;

import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;

import io.quarkus.arc.AlternativePriority;
import io.quarkus.oidc.AuthorizationCodeTokens;
import io.quarkus.oidc.OidcTenantConfig;
import io.quarkus.oidc.TokenStateManager;
import io.quarkus.oidc.runtime.DefaultTokenStateManager;
import io.smallrye.mutiny.Uni;
import io.vertx.ext.web.RoutingContext;

@ApplicationScoped
@AlternativePriority(1)
public class CustomTokenStateManager implements TokenStateManager {

    @Inject
    DefaultTokenStateManager tokenStateManager;

    @Override
    public Uni<String> createTokenState(RoutingContext routingContext, OidcTenantConfig oidcConfig,
            AuthorizationCodeTokens sessionContent, TokenStateManager.CreateTokenStateRequestContext requestContext) {
        return tokenStateManager.createTokenState(routingContext, oidcConfig, sessionContent, requestContext)
                .map(t -> (t + ""|custom""));
    }

    @Override
    public Uni<AuthorizationCodeTokens> getTokens(RoutingContext routingContext, OidcTenantConfig oidcConfig,
            String tokenState, TokenStateManager.GetTokensRequestContext requestContext) {
        if (!tokenState.endsWith(""|custom"")) {
            throw new IllegalStateException();
        }
        String defaultState = tokenState.substring(0, tokenState.length() - 7);
        return tokenStateManager.getTokens(routingContext, oidcConfig, defaultState, requestContext);
    }

    @Override
    public Uni<Void> deleteTokens(RoutingContext routingContext, OidcTenantConfig oidcConfig, String tokenState,
            TokenStateManager.DeleteTokensRequestContext requestContext) {
        if (!tokenState.endsWith(""|custom"")) {
            throw new IllegalStateException();
        }
        String defaultState = tokenState.substring(0, tokenState.length() - 7);
        return tokenStateManager.deleteTokens(routingContext, oidcConfig, defaultState, requestContext);
    }
}
----

== Listening to important authentication events

One can register `@ApplicationScoped` bean which will observe important OIDC authentication events. The listener will be updated when a user has logged in for the first time or re-authenticated, as well as when the session has been refreshed. More events may be reported in the future. For example:

[source, java]
----
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.event.Observes;

import io.quarkus.oidc.IdTokenCredential;
import io.quarkus.oidc.SecurityEvent;
import io.quarkus.security.identity.AuthenticationRequestContext;
import io.vertx.ext.web.RoutingContext;

@ApplicationScoped
public class SecurityEventListener {

    public void event(@Observes SecurityEvent event) {
        String tenantId = event.getSecurityIdentity().getAttribute(""tenant-id"");
        RoutingContext vertxContext = event.getSecurityIdentity().getCredential(IdTokenCredential.class).getRoutingContext();
        vertxContext.put(""listener-message"", String.format(""event:%s,tenantId:%s"", event.getEventType().name(), tenantId));
    }
}
----

== Single Page Applications

Please check if implementing SPAs the way it is suggested in the link:security-openid-connect#single-page-applications[Single Page Applications for Service Applications] section can meet your requirements.

If you prefer to use SPA and JavaScript API such as `Fetch` or `XMLHttpRequest`(XHR) with Quarkus web applications, please be aware that OpenID Connect Providers may not support CORS for Authorization endpoints where the users are authenticated after a redirect from Quarkus. This will lead to authentication failures if the Quarkus application and the OpenID Connect Provider are hosted on the different HTTP domains/ports.

In such cases, set the `quarkus.oidc.authentication.java-script-auto-redirect` property to `false` which will instruct Quarkus to return a `499` status code and `WWW-Authenticate` header with the `OIDC` value. The browser script also needs to be updated to set `X-Requested-With` header with the `JavaScript` value and reload the last requested page in case of `499`, for example:

[source,javascript]
----
Future<void> callQuarkusService() async {
    Map<String, String> headers = Map.fromEntries([MapEntry(""X-Requested-With"", ""JavaScript"")]);

    await http
        .get(""https://localhost:443/serviceCall"")
        .then((response) {
            if (response.statusCode == 499) {
                window.location.assign(""https://localhost.com:443/serviceCall"");
            }
         });
  }
----

== Integration with GitHub and other OAuth2 providers

Some well known providers such as `GitHub` or `LinkedIn` are not `OpenId Connect` but `OAuth2` providers which support the `authorization code flow`, for example, link:https://docs.github.com/en/developers/apps/building-oauth-apps/authorizing-oauth-apps[GitHub OAuth2] and link:https://docs.microsoft.com/en-us/linkedin/shared/authentication/authorization-code-flow[LinkedIn OAuth2].

The main difference between `OAuth2` and `OpenId Connect` providers is that `OpenId Connect` providers, by building on top of `OAuth2`, return an `ID Token` representing a user authentication, in addition to the standard authorization code flow access and refresh tokens returned by `OAuth2` providers. With `OAuth2` providers, the fact of the user authentication is implicit and is indirectly represented by the access token which represents an authenticated user authorizing the current Quarkus `web-app` application to access some data on behalf of this user.

For example, when working with `GitHub`, the Quarkus endpoint can acquire an access token which will allow it to request a `GitHub` user profile of the current user.
In fact this is exactly how a standard `OpenId Connect` `UserInfo` acqusition also works - by authenticating into your `OpenId Connect` provider you also give a permission to Quarkus application to acquire your `UserInfo` on your behalf - and it also shows what is meant by `OpenId Connect` being built on top of `OAuth2`.

In order to support the integration with such `OAuth2` servers, `quarkus-oidc` needs to be configured to allow the authorization code flow responses without `IdToken`: `quarkus.oidc.authentication.id-token-required=false`.

The next step is to ensure that the returned access token can be useful to the current Quarkus endpoint.
If the `OAuth2` provider supports the introspection endpoint then you may be able to use this access token as a source of roles with `quarkus.oidc.roles.source=accesstoken`. If no introspection endpoint is available then at the very least it should be possible to request a user information from this provider with `quarkus.oidc.authentication.user-info-required` - this is the case with `GitHib`.

Also, OAuth2 servers may not support a well-known configuration endpoint in which case the discovery has to be disabled and the authorization, token, and introspection and/or userinfo endpoint paths have to be configured manually.

Here is how you can integrate `quarkus-oidc` with `GitHub` after you have link:https://docs.github.com/en/developers/apps/building-oauth-apps/creating-an-oauth-app[created a GitHub OAuth application]. Configure your Quarkus endpoint like this:

```properties
quarkus.oidc.auth-server-url=https://github.com/login/oauth
quarkus.oidc.discovery-enabled=false
quarkus.oidc.authorization-path=authorize
quarkus.oidc.token-path=access_token
quarkus.oidc.user-info-path=https://api.github.com/user

# See https://docs.github.com/en/developers/apps/building-oauth-apps/scopes-for-oauth-apps
quarkus.oidc.authentication.scopes=user:email

# Make sure a user info is required
quarkus.oidc.authentication.user-info-required=true

# Allow the code flow responses without ID tokens
quarkus.oidc.authentication.id-token-required=false

quarkus.oidc.application-type=web-app

quarkus.oidc.client-id=github_app_clientid
quarkus.oidc.credentials.secret=github_app_clientsecret
```

This is all what is needed for an endpoint like this one to return the currently authenticated user's profile with `GET http:localhost:8080/github/userinfo`:

```java
import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;

import io.quarkus.oidc.UserInfo;
import io.quarkus.security.Authenticated;

@Path(""/github"")
@Authenticated
public class TokenResource {

    @Inject
    UserInfo userInfo;

    @GET
    @Path(""/userinfo"")
    @Produces(""application/json"")
    public String getUserInfo() {
        return userInfo.getUserInfoString();
    }
}
```

In your own endpoint you can access individual `UserInfo` properties as required.

The last important point is to make sure the callback path you enter in the GitHub OAuth application configuration matches the endpoint path where you'd like the user be redirected to after a successful GitHub authentication and application authorization, in this case it has to be set to `http:localhost:8080/github/userinfo`.

== Cloud Services

=== Google Cloud

You can have Quarkus OIDC `web-app` applications access **Google Cloud services** such as **BigQuery** on behalf of the currently authenticated users who have enabled OpenID Connect (Authorization Code Flow) permissions to such services in their Google Developer Consoles.

It is super easy to do with https://github.com/quarkiverse[Quarkiverse] https://github.com/quarkiverse/quarkiverse-google-cloud-services[Google Cloud Services], only add
the https://github.com/quarkiverse/quarkiverse-google-cloud-services/releases/latest[latest tag] service dependency, for example:

[source,xml]
----
<dependency>
  <groupId>io.quarkiverse.googlecloudservices</groupId>
  <artifactId>quarkus-google-cloud-bigquery</artifactId>
  <version>${quarkiverse.googlecloudservices.version}</version>
</dependency>
----

and configure Google OIDC properties:

[source, properties]
----
quarkus.oidc.auth-server-url=https://accounts.google.com
quarkus.oidc.application-type=web-app
quarkus.oidc.client-id={GOOGLE_CLIENT_ID}
quarkus.oidc.credentials.secret={GOOGLE_CLIENT_SECRET}
quarkus.oidc.token.issuer=https://accounts.google.com
----

== Provider Endpoint configuration

OIDC `web-app` application needs to know OpenId Connect provider's authorization, token, `JsonWebKey` (JWK) set and possibly `UserInfo`, introspection and end session (RP-initiated logout) endpoint addresses.

By default they are discovered by adding a `/.well-known/openid-configuration` path to the configured `quarkus.oidc.auth-server-url`.

Alternatively, if the discovery endpoint is not available or you would like to save on the discovery endpoint roundtrip, you can disable the discovery and configure them with relative path values, for example:

[source, properties]
----
quarkus.oidc.auth-server-url=http://localhost:8180/auth/realms/quarkus
quarkus.oidc.discovery-enabled=false
# Authorization endpoint: http://localhost:8180/auth/realms/quarkus/protocol/openid-connect/auth
quarkus.oidc.authorization-path=/protocol/openid-connect/auth
# Token endpoint: http://localhost:8180/auth/realms/quarkus/protocol/openid-connect/token
quarkus.oidc.token-path=/protocol/openid-connect/token
# JWK set endpoint: http://localhost:8180/auth/realms/quarkus/protocol/openid-connect/certs
quarkus.oidc.jwks-path=/protocol/openid-connect/certs
# UserInfo endoint: http://localhost:8180/auth/realms/quarkus/protocol/openid-connect/userinfo
quarkus.oidc.user-info-path=/protocol/openid-connect/userinfo
# Token Introspection endoint: http://localhost:8180/auth/realms/quarkus/protocol/openid-connect/token/introspect
quarkus.oidc.introspection-path=/protocol/openid-connect/token/introspect
# End session endoint: http://localhost:8180/auth/realms/quarkus/protocol/openid-connect/logout
quarkus.oidc.end-session-path=/protocol/openid-connect/logout
----

[[jwt-claim-verification]]
== JSON Web Token Claim Verification

Please see link:security-openid-connect#jwt-claim-verification[JSON Web Token Claim verification] section about the claim verification, including the `iss` (issuer) claim.
It applies to ID tokens but also to access tokens in a JWT format if the `web-app` application has requested the access token verification.

== Token Propagation
Please see link:security-openid-connect-client#token-propagation[Token Propagation] section about the Authorization Code Flow access token propagation to the downstream services.

[[oidc-provider-client-authentication]]
== Oidc Provider Client Authentication

`quarkus.oidc.runtime.OidcProviderClient` is used when a remote request to an OpenId Connect Provider has to be done. It has to authenticate to the OpenId Connect Provider when the authorization code has to be exchanged for the ID, access and refresh tokens, when the ID and access tokens have to be refreshed or introspected.

All the https://openid.net/specs/openid-connect-core-1_0.html#ClientAuthentication[OIDC Client Authentication] options are supported, for example:

`client_secret_basic`:

[source,properties]
----
quarkus.oidc.auth-server-url=http://localhost:8180/auth/realms/quarkus/
quarkus.oidc.client-id=quarkus-app
quarkus.oidc.credentials.secret=mysecret
----

or

[source,properties]
----
quarkus.oidc.auth-server-url=http://localhost:8180/auth/realms/quarkus/
quarkus.oidc.client-id=quarkus-app
quarkus.oidc.credentials.client-secret.value=mysecret
----

or with the secret retrieved from a link:credentials-provider[CredentialsProvider]:

[source,properties]
----
quarkus.oidc.auth-server-url=http://localhost:8180/auth/realms/quarkus/
quarkus.oidc.client-id=quarkus-app

# This is a key which will be used to retrieve a secret from the map of credentails returned from CredentialsProvider
quarkus.oidc.credentials.client-secret.provider.key=mysecret-key
# Set it only if more than one CredentialsProvider can be registered
quarkus.oidc.credentials.client-secret.provider.name=oidc-credentials-provider
----

`client_secret_post`:

[source,properties]
----
quarkus.oidc.auth-server-url=http://localhost:8180/auth/realms/quarkus/
quarkus.oidc.client-id=quarkus-app
quarkus.oidc.credentials.client-secret.value=mysecret
quarkus.oidc.credentials.client-secret.method=post
----

`client_secret_jwt`:

[source,properties]
----
quarkus.oidc.auth-server-url=http://localhost:8180/auth/realms/quarkus/
quarkus.oidc.client-id=quarkus-app
quarkus.oidc.credentials.jwt.secret=AyM1SysPpbyDfgZld3umj1qzKObwVMkoqQ-EstJQLr_T-1qS0gZH75aKtMN3Yj0iPS4hcgUuTwjAzZr1Z9CAow
# This is a token key identifier 'kid' header - set it if your OpenId Connect provider requires it,
quarkus.oidc.credentials.jwt.token-key-id=mykey
----

or with the secret retrieved from a link:credentials-provider[CredentialsProvider]:

[source,properties]
----
quarkus.oidc.auth-server-url=http://localhost:8180/auth/realms/quarkus/
quarkus.oidc.client-id=quarkus-app

# This is a key which will be used to retrieve a secret from the map of credentails returned from CredentialsProvider
quarkus.oidc.credentials.jwt.secret-provider.key=mysecret-key
# Set it only if more than one CredentialsProvider can be registered
quarkus.oidc.credentials.jwt.secret-provider.name=oidc-credentials-provider
----

`private_key_jwt` with the PEM key file:

[source,properties]
----
quarkus.oidc.auth-server-url=http://localhost:8180/auth/realms/quarkus/
quarkus.oidc.client-id=quarkus-app
quarkus.oidc.credentials.jwt.key-file=privateKey.pem
# This is a token key identifier 'kid' header - set it if your OpenId Connect provider requires it
quarkus.oidc.credentials.jwt.token-key-id=mykey
----

`private_key_jwt` with the key store file:

[source,properties]
----
quarkus.oidc.auth-server-url=http://localhost:8180/auth/realms/quarkus/
quarkus.oidc.client-id=quarkus-app
quarkus.oidc.credentials.jwt.key-store-file=keystore.jks
quarkus.oidc.credentials.jwt.key-store-password=mypassword
quarkus.oidc.credentials.jwt.key-password=mykeypassword
# Private key alias inside the keystore
quarkus.oidc.credentials.jwt.key-id=mykey
# This is a token key identifier 'kid' header - set it if your OpenId Connect provider requires it,
# Note it can be different to the `quarkus.oidc.credentials.jwt.key-id` value
quarkus.oidc.credentials.jwt.token-key-id=mykey
----

Using `client_secret_jwt` or `private_key_jwt` authentication methods ensures that no client secret goes over the wire.

[[integration-testing]]
== Testing

Start by adding the following dependencies to your test project:

[source,xml]
----
<dependency>
    <groupId>net.sourceforge.htmlunit</groupId>
    <artifactId>htmlunit</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>*</artifactId>
       </exclusion>
    </exclusions>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-junit5</artifactId>
    <scope>test</scope>
</dependency>
----

[[integration-testing-wiremock]]
=== Wiremock

Add the following dependency:

[source,xml]
----
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-test-oidc-server</artifactId>
    <scope>test</scope>
</dependency>
----

Prepare the REST test endpoints, set `application.properties`, for example:

[source, properties]
----
# keycloak.url is set by OidcWiremockTestResource
quarkus.oidc.auth-server-url=${keycloak.url}/realms/quarkus/
quarkus.oidc.client-id=quarkus-web-app
quarkus.oidc.credentials.secret=secret
quarkus.oidc.application-type=web-app
----

and finally write the test code, for example:

[source, java]
----
import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.Test;

import com.gargoylesoftware.htmlunit.SilentCssErrorHandler;
import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.html.HtmlForm;
import com.gargoylesoftware.htmlunit.html.HtmlPage;

import io.quarkus.test.common.QuarkusTestResource;
import io.quarkus.test.junit.QuarkusTest;
import io.quarkus.test.oidc.server.OidcWiremockTestResource;

@QuarkusTest
@QuarkusTestResource(OidcWiremockTestResource.class)
public class CodeFlowAuthorizationTest {

    @Test
    public void testCodeFlow() throws Exception {
        try (final WebClient webClient = createWebClient()) {
            // the test REST endpoint listens on '/code-flow'
            HtmlPage page = webClient.getPage(""http://localhost:8081/code-flow"");

            HtmlForm form = page.getFormByName(""form"");
            // user 'alice' has the 'user' role
            form.getInputByName(""username"").type(""alice"");
            form.getInputByName(""password"").type(""alice"");

            page = form.getInputByValue(""login"").click();

            assertEquals(""alice"", page.getBody().asText());
        }
    }

    private WebClient createWebClient() {
        WebClient webClient = new WebClient();
        webClient.setCssErrorHandler(new SilentCssErrorHandler());
        return webClient;
    }
}
----

`OidcWiremockTestResource` recognizes `alice` and `admin` users. The user `alice` has the `user` role only by default - it can be customized with a `quarkus.test.oidc.token.user-roles` system property. The user `admin` has the `user` and `admin` roles by default - it can be customized with a `quarkus.test.oidc.token.admin-roles` system property.

Additionally, `OidcWiremockTestResource` set token issuer and audience to `https://service.example.com` which can be customized with `quarkus.test.oidc.token.issuer` and `quarkus.test.oidc.token.audience` system properties.

`OidcWiremockTestResource` can be used to emulate all OpenId Connect providers.

[[integration-testing-keycloak-devservices]]
=== Dev Services for Keycloak

Using link:security-openid-connect-dev-services[Dev Services for Keycloak] is recommended for the integration testing against Keycloak.
`Dev Services for Keycloak` will launch and initialize a test container: it will create a `quarkus` realm, a `quarkus-app` client (`secret` secret) and add `alice` (`admin` and `user` roles) and `bob` (`user` role) users, where all of these properties can be customized.

First prepare `application.properties`. You can start with a completely empty `application.properties` as `Dev Services for Keycloak` will register `quarkus.oidc.auth-server-url` pointing to the running test container as well as `quarkus.oidc.client-id=quarkus-app` and `quarkus.oidc.credentials.secret=secret`.

But if you already have all the required `quarkus-oidc` properties configured then you only need to associate `quarkus.oidc.auth-server-url` with the `prod` profile for `Dev Services for Keycloak`to start a container, for example:

[source,properties]
----
%prod.quarkus.oidc.auth-server-url=http://localhost:8180/auth/realms/quarkus
----

If a custom realm file has to be imported into Keycloak before running the tests then you can configure `Dev Services for Keycloak` as follows:

[source,properties]
----
%prod.quarkus.oidc.auth-server-url=http://localhost:8180/auth/realms/quarkus
quarkus.keycloak.devservices.realm-path=quarkus-realm.json
----

Finally write a test code the same way as it is described in the <<integration-testing-wiremock, Wiremock>> section above.
The only difference is that `@QuarkusTestResource` is no longer needed:

[source, java]
----
@QuarkusTest
public class CodeFlowAuthorizationTest {
}
----

[[integration-testing-keycloak]]
=== KeycloakTestResourceLifecycleManager

If you need to do the integration testing against Keycloak then you are encouraged to do it with <<integration-testing-keycloak-devservices,Dev Services For Keycloak>>.
Use `KeycloakTestResourceLifecycleManager` for your tests only if there is a good reason not to use `Dev Services for Keycloak`.

Start with adding the following dependency:

[source,xml]
----
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-test-keycloak-server</artifactId>
    <scope>test</scope>
</dependency>
----

which provides `io.quarkus.test.keycloak.server.KeycloakTestResourceLifecycleManager` - an implementaion of `io.quarkus.test.common.QuarkusTestResourceLifecycleManager` which starts a Keycloak container.

And configure `maven.surefire.plugin` as follows:

[source,xml]
----
<plugin>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
        <systemPropertyVariables>
            <!-- or, alternativey, configure 'keycloak.version' -->
            <keycloak.docker.image>${keycloak.docker.image}</keycloak.docker.image>
            <!--
              Disable HTTPS if required:
              <keycloak.use.https>false</keycloak.use.https>
            -->
        </systemPropertyVariables>
    </configuration>
</plugin>
----

(and similarly `maven.failsafe.plugin` when testing in native image).

And now set the configuration and write the test code the same way as it is described in the <<integration-testing-wiremock, Wiremock>> section above.
The only difference is the name of `QuarkusTestResource`:

[source, java]
----
import io.quarkus.test.keycloak.server.KeycloakTestResourceLifecycleManager;

@QuarkusTest
@QuarkusTestResource(KeycloakTestResourceLifecycleManager.class)
public class CodeFlowAuthorizationTest {
}
----

`KeycloakTestResourceLifecycleManager` registers `alice` and `admin` users. The user `alice` has the `user` role only by default - it can be customized with a `keycloak.token.user-roles` system property. The user `admin` has the `user` and `admin` roles by default - it can be customized with a `keycloak.token.admin-roles` system property.

By default, `KeycloakTestResourceLifecycleManager` uses HTTPS to initialize a Keycloak instance which can be disabled with `keycloak.use.https=false`.
Default realm name is `quarkus` and client id - `quarkus-web-app` - set `keycloak.realm` and `keycloak.web-app.client` system properties to customize the values if needed.

[[integration-testing-security-annotation]]
=== TestSecurity annotation

Please see link:security-openid-connect#integration-testing-security-annotation[Use TestingSecurity with injected JsonWebToken] section for more information about using `@TestSecurity` and `@OidcSecurity` annotations for testing the `web-app` application endpoint code which depends on the injected ID and access `JsonWebToken` as well as `UserInfo` and `OidcConfigurationMetadata`.

== How to check the errors in the logs ==

Please enable `io.quarkus.oidc.runtime.OidcProvider` `TRACE` level logging to see more details about the token verification errors:

[source, properties]
----
quarkus.log.category.""io.quarkus.oidc.runtime.OidcProvider"".level=TRACE
quarkus.log.category.""io.quarkus.oidc.runtime.OidcProvider"".min-level=TRACE
----

Please enable `io.quarkus.oidc.runtime.OidcRecorder` `TRACE` level logging to see more details about the OidcProvider client initialization errors:

[source, properties]
----
quarkus.log.category.""io.quarkus.oidc.runtime.OidcRecorder"".level=TRACE
quarkus.log.category.""io.quarkus.oidc.runtime.OidcRecorder"".min-level=TRACE
----

== Running behind a reverse proxy

OIDC authentication mechanism can be affected if your Quarkus application is running behind a reverse proxy/gateway/firewall when HTTP `Host` header may be reset to the internal IP address, HTTPS connection may be terminated, etc. For example, an authorization code flow `redirect_uri` parameter may be set to the internal host instead of the expected external one.

In such cases configuring Quarkus to recognize the original headers forwarded by the proxy will be required, see link:http-reference#reverse-proxy[Running behind a reverse proxy] Vert.x documentation section for more information.

For example, if your Quarkus endpoint runs in a cluster behind Kubernetes Ingress then a redirect from the OpenId Connect Provider back to this endpoint may not work since the calcuated `redirect_uri` parameter may point to the internal endpoint address. This problem can be resolved with the following configuration:

[source,properties]
----
quarkus.http.proxy.proxy-address-forwarding=true
quarkus.http.proxy.allow-forwarded=false
quarkus.http.proxy.enable-forwarded-host=true
quarkus.http.proxy.forwarded-host-header=X-ORIGINAL-HOST
----

where `X-ORIGINAL-HOST` is set by Kubernetes Ingress to represent the external endpoint address.

`quarkus.oidc.authentication.force-redirect-https-scheme` property may also be used when the Quarkus application is running behind a SSL terminating reverse proxy.

== External and Internal Access to OpenId Connect Provider

Note that the OpenId Connect Provider externally accessible authorization, logout and other endpoints may have different HTTP(S) URLs compared to the URLs auto-discovered or configured relative to `quarkus.oidc.auth-server-url` internal URL.
In such cases an issuer verification failure may be reported by the endpoint and redirects to the externally accessible Connect Provider endpoints may fail.

In such cases, if you work with Keycloak then please start it with a `KEYCLOAK_FRONTEND_URL` system property set to the externally accessible base URL.
If you work with other Openid Connect providers then please check your provider's documentation.

== Customize authentication requests

By default, only the `response_type` (set to `code`), `scope` (set to 'openid'), `client_id`, `redirect_uri` and `state` properties are passed as HTTP query parameters to the OpenId Connect provider's authorization endpoint when the user is redirected to it to authenticate.

You can add more properties to it with `quarkus.oidc.authentication.extra-params`. For example, some OpenId Connect providers may choose to return the authorization code as part of the redirect URI's fragment which would break the authentication process - it can be fixed as follows:

[source,properties]
----
quarkus.oidc.authentication.extra-params.response_mode=query
----

== Configuration Reference

include::{generated-dir}/config/quarkus-oidc.adoc[opts=optional]

== References

* https://www.keycloak.org/documentation.html[Keycloak Documentation]
* https://openid.net/connect/[OpenID Connect]
* https://tools.ietf.org/html/rfc7519[JSON Web Token]
* link:security-openid-connect-client[Quarkus - Using OpenID Connect and OAuth2 Client and Filters to manage access tokens]
* link:security-openid-connect-dev-services[Dev Services for Keycloak]
* link:security[Quarkus Security]
",12542,False,2361.635513954632,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.autoConfiguration{zwsp}SystemPropertiesEnabled* | Whether auto configuration should include JVM system properties as well. When enabled this allows to overrule any configuration using a JVM system property. For example to set a shutdown timeout of 5 seconds: -D camel.main.shutdown-timeout=5. Note that JVM system properties take precedence over OS environment variables. 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.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 RouteBuilder classes which are collected from the registry or via classpath scanning. 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 RouteBuilder classes which are collected from the registry or via classpath scanning. The exclusive filtering takes precedence over inclusive filtering. The pattern is using Ant-path style pattern. Multiple patterns can be specified separated by comma. 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}LoggingLevel* | Sets the logging level used for logging route activity (such as starting and stopping routes). The default logging level is DEBUG. | DEBUG | 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 routes from the file system). The routes collector is default enabled. | true | boolean
| *camel.main.routesExclude{zwsp}Pattern* | Used for exclusive filtering of routes from directories. The exclusive filtering takes precedence over inclusive filtering. The pattern is using Ant-path style pattern. Multiple patterns can be specified separated by comma, as example, to exclude all the routes from a directory whose name contains foo use: &#42;&#42;/foo. |  | String
| *camel.main.routesInclude{zwsp}Pattern* | Used for inclusive filtering of routes from directories. The exclusive filtering takes precedence over inclusive filtering. The pattern is using Ant-path style pattern. Multiple patterns can be specified separated by comma, as example, to include all the routes from a directory whose name contains foo use: &#42;&#42;/foo. | classpath:camel/*.xml,classpath:camel-template/*.xml,classpath:camel-rest/*.xml | String
| *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.startupRecorder* | To use startup recorder for capturing execution time during starting Camel. The recorder can be one of: false, logging, java-flight-recorder The default is false. |  | String
| *camel.main.startupRecorderDir* | Directory to store the recording. By default the user home directory will be used. Use false to turn off saving recording to disk. |  | String
| *camel.main.startupRecorder{zwsp}Duration* | How long time to run the startup recorder. Use 0 (default) to keep the recorder running until the JVM is exited. Use -1 to stop the recorder right after Camel has been started (to only focus on potential Camel startup performance bottlenecks) Use a positive value to keep recording for N seconds. When the recorder is stopped then the recording is auto saved to disk (note: save to disk can be disabled by setting startupRecorderDir to false) |  | long
| *camel.main.startupRecorderMax{zwsp}Depth* | To filter our sub steps at a maximum depth. Use -1 for no maximum. Use 0 for no sub steps. Use 1 for max 1 sub step, and so forth. The default is -1. | -1 | int
| *camel.main.startupRecorder{zwsp}Profile* | To use a specific Java Flight Recorder profile configuration, such as default or profile. The default is default. | default | String
| *camel.main.startupRecorder{zwsp}Recording* | To enable Java Flight Recorder to start a recording and automatic dump the recording to disk after startup is complete. This requires that camel-jfr is on the classpath, and to enable this option. |  | boolean
| *camel.main.startupSummaryLevel* | Controls the level of information logged during startup (and shutdown) of CamelContext. | Default | StartupSummaryLevel
| *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.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`.
",12463,False,2200.515009497083,median
"//
// Copyright 2017 Pixar
//
// Licensed under the Apache License, Version 2.0 (the ""Apache License"")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an ""AS IS"" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#include ""pxr/imaging/hdx/taskController.h""

#include ""pxr/imaging/hd/camera.h""
#include ""pxr/imaging/hd/renderBuffer.h""
#include ""pxr/imaging/hd/renderDelegate.h""
#include ""pxr/imaging/hd/sceneDelegate.h""
#include ""pxr/imaging/hdx/aovInputTask.h""
#include ""pxr/imaging/hdx/colorizeSelectionTask.h""
#include ""pxr/imaging/hdx/colorChannelTask.h""
#include ""pxr/imaging/hdx/colorCorrectionTask.h""
#include ""pxr/imaging/hdx/oitRenderTask.h""
#include ""pxr/imaging/hdx/oitResolveTask.h""
#include ""pxr/imaging/hdx/oitVolumeRenderTask.h""
#include ""pxr/imaging/hdx/package.h""
#include ""pxr/imaging/hdx/pickTask.h""
#include ""pxr/imaging/hdx/pickFromRenderBufferTask.h""
#include ""pxr/imaging/hdx/presentTask.h""
#include ""pxr/imaging/hdx/renderTask.h""
#include ""pxr/imaging/hdx/selectionTask.h""
#include ""pxr/imaging/hdx/simpleLightTask.h""
#include ""pxr/imaging/hdx/shadowTask.h""
#include ""pxr/imaging/hdx/tokens.h""

#include ""pxr/imaging/hdSt/light.h""
#include ""pxr/imaging/hdSt/renderDelegate.h""
#include ""pxr/imaging/hdSt/tokens.h""

#include ""pxr/imaging/glf/simpleLight.h""
#include ""pxr/imaging/glf/simpleLightingContext.h""

#include ""pxr/base/gf/camera.h""

PXR_NAMESPACE_OPEN_SCOPE

TF_DEFINE_PRIVATE_TOKENS(
    _tokens,

    // tasks
    (simpleLightTask)
    (shadowTask)
    (aovInputTask)
    (selectionTask)
    (colorizeSelectionTask)
    (oitResolveTask)
    (colorCorrectionTask)
    (colorChannelTask)
    (pickTask)
    (pickFromRenderBufferTask)
    (presentTask)

    // global camera
    (camera)

    // For the internal delegate...
    (renderBufferDescriptor)
    (renderTags)

    // for the stage orientation
    (StageOrientation)
);

// ---------------------------------------------------------------------------
// Delegate implementation.

/* virtual */
VtValue
HdxTaskController::_Delegate::Get(SdfPath const& id, TfToken const& key)
{
    _ValueCache *vcache = TfMapLookupPtr(_valueCacheMap, id);
    VtValue ret;
    if (vcache && TfMapLookup(*vcache, key, &ret)) {
        return ret;
    }
    TF_CODING_ERROR(""%s:%s doesn't exist in the value cache\\n"",
            id.GetText(), key.GetText());
    return VtValue();
}

/* virtual */
GfMatrix4d
HdxTaskController::_Delegate::GetTransform(SdfPath const& id)
{
    // Extract from value cache.
    if (_ValueCache *vcache = TfMapLookupPtr(_valueCacheMap, id)) {
        if (VtValue * val = TfMapLookupPtr(*vcache, HdTokens->transform)) {
            if (val->IsHolding<GfMatrix4d>()) {
                return val->Get<GfMatrix4d>();
            }
        }
    }

    TF_CODING_ERROR(
        ""Unexpected call to GetTransform for %s in HdxTaskController's ""
        ""internal scene delegate.\\n"", id.GetText());
    return GfMatrix4d(1.0);
}

/* virtual */
VtValue
HdxTaskController::_Delegate::GetCameraParamValue(SdfPath const& id, 
                                                  TfToken const& key)
{   
    if ( key == HdCameraTokens->projection ||
         key == HdCameraTokens->horizontalAperture ||
         key == HdCameraTokens->verticalAperture ||
         key == HdCameraTokens->horizontalApertureOffset ||
         key == HdCameraTokens->verticalApertureOffset ||
         key == HdCameraTokens->focalLength ||
         key == HdCameraTokens->clippingRange ||
         key == HdCameraTokens->clipPlanes ||
         key == HdCameraTokens->windowPolicy) {
        return Get(id, key);
    } else {
        // Return empty VtValue for, e.g., fStop not in the
        // value cache.
        return VtValue();
    }
}

/* virtual */
VtValue
HdxTaskController::_Delegate::GetLightParamValue(SdfPath const& id, 
                                                 TfToken const& paramName)
{   
    return Get(id, paramName);
}

/* virtual */
bool
HdxTaskController::_Delegate::IsEnabled(TfToken const& option) const
{
    return HdSceneDelegate::IsEnabled(option);
}

/* virtual */
HdRenderBufferDescriptor
HdxTaskController::_Delegate::GetRenderBufferDescriptor(SdfPath const& id)
{
    return GetParameter<HdRenderBufferDescriptor>(id,
                _tokens->renderBufferDescriptor);
}


/* virtual */
TfTokenVector
HdxTaskController::_Delegate::GetTaskRenderTags(SdfPath const& taskId)
{
    if (HasParameter(taskId, _tokens->renderTags)) {
        return GetParameter<TfTokenVector>(taskId, _tokens->renderTags);
    }
    return TfTokenVector();
}


// ---------------------------------------------------------------------------
// Task controller implementation.

static bool
_IsStormRenderingBackend(HdRenderIndex const *index)
{
    if(!dynamic_cast<HdStRenderDelegate*>(index->GetRenderDelegate())) {
        return false;
    }

    return true;
}

static GfVec2i
_ViewportToAovDimensions(const GfVec4d& viewport)
{
    // Ignore the viewport offset and use its size as the aov size.
    // XXX: This is fragile and doesn't handle viewport tricks,
    // such as camera zoom. In the future, we expect to improve the
    // API to better communicate AOV sizing, fill region and camera
    // zoom.
    return GfVec2i(viewport[2], viewport[3]);
}

HdxTaskController::HdxTaskController(HdRenderIndex *renderIndex,
                                     SdfPath const& controllerId)
    : _index(renderIndex)
    , _controllerId(controllerId)
    , _delegate(renderIndex, controllerId)
    , _renderBufferSize(0, 0)
    , _overrideWindowPolicy{false, CameraUtilFit}
    , _viewport(0, 0, 1, 1)
{
    _CreateRenderGraph();
}

HdxTaskController::~HdxTaskController()
{
    if (_freeCamId != SdfPath::EmptyPath()) {
        GetRenderIndex()->RemoveSprim(HdPrimTypeTokens->camera, _freeCamId);
    }

    SdfPath const tasks[] = {
        _aovInputTaskId,
        _oitResolveTaskId,
        _selectionTaskId,
        _simpleLightTaskId,
        _shadowTaskId,
        _colorizeSelectionTaskId,
        _colorCorrectionTaskId,
        _pickTaskId,
        _pickFromRenderBufferTaskId,
        _presentTaskId
    };

    for (size_t i = 0; i < sizeof(tasks)/sizeof(tasks[0]); ++i) {
        if (!tasks[i].IsEmpty()) {
            GetRenderIndex()->RemoveTask(tasks[i]);
        }
    }

    for (auto const& id : _renderTaskIds) {
        GetRenderIndex()->RemoveTask(id);
    }

    for (auto const& id : _lightIds) {
        GetRenderIndex()->RemoveSprim(HdPrimTypeTokens->simpleLight, id);
        GetRenderIndex()->RemoveSprim(HdPrimTypeTokens->domeLight, id);
    }

    for (auto const& id : _aovBufferIds) {
        GetRenderIndex()->RemoveBprim(HdPrimTypeTokens->renderBuffer, id);
    }
}

void
HdxTaskController::_CreateRenderGraph()
{
    // We create camera and tasks here, but lights are created lazily by
    // SetLightingState. Camera needs to be created first, since it's a
    // parameter of most tasks.
    if (_CamerasSupported()) {
        _CreateCamera();
    }

    // XXX: The general assumption is that we have ""Storm"" backends which are
    // rasterization based and have their own rules, like multipass for
    // transparency; and other backends are more single-pass.  As render
    // delegate capabilities evolve, we'll need a more complicated switch
    // than this...
    if (_IsStormRenderingBackend(GetRenderIndex())) {
        _CreateLightingTask();
        _CreateShadowTask();
        _renderTaskIds.push_back(_CreateRenderTask(
            HdMaterialTagTokens->defaultMaterialTag));
        _renderTaskIds.push_back(_CreateRenderTask(
            HdStMaterialTagTokens->masked));
        _renderTaskIds.push_back(_CreateRenderTask(
            HdxMaterialTagTokens->additive));
        _renderTaskIds.push_back(_CreateRenderTask(
            HdxMaterialTagTokens->translucent));
        _renderTaskIds.push_back(_CreateRenderTask(
            HdStMaterialTagTokens->volume));

        if (_AovsSupported()) {
            _CreateAovInputTask();
            _CreateOitResolveTask();
            _CreateSelectionTask();
            _CreateColorCorrectionTask();
            _CreatePresentTask();
        }

        // Picking rendergraph
        _CreatePickTask();

        // XXX AOVs are OFF by default for Storm TaskController because hybrid
        // rendering in Presto spawns an ImagineGLEngine, which creates a task
        // controlller. But the Hydrid rendering setups are not yet AOV ready
        // since it breaks main cam zoom operations expressed via viewport
        // manipulation.
        // App (UsdView) for now calls engine->SetRendererAov(color) to enable.
        // SetRenderOutputs({HdAovTokens->color});
    } else {
        _renderTaskIds.push_back(_CreateRenderTask(TfToken()));

        if (_AovsSupported()) {
            _CreateAovInputTask();
            _CreateColorizeSelectionTask();
            _CreatePickFromRenderBufferTask();
            _CreateColorCorrectionTask();
            _CreatePresentTask();
            // Initialize the AOV system to render color. Note:
            // SetRenderOutputs special-cases color to include support for
            // depth-compositing and selection highlighting/picking.
            SetRenderOutputs({HdAovTokens->color});
        }
    }
}

void
HdxTaskController::_CreateCamera()
{
    // Create a default camera, driven by SetFreeCameraMatrices.
    _freeCamId = GetControllerId().AppendChild(_tokens->camera);
    GetRenderIndex()->InsertSprim(HdPrimTypeTokens->camera,
        &_delegate, _freeCamId);

    _delegate.SetParameter(_freeCamId, HdCameraTokens->windowPolicy,
        VtValue(CameraUtilFit));
    _delegate.SetParameter(_freeCamId, HdTokens->transform,
        VtValue(GfMatrix4d(1.0)));
    _delegate.SetParameter(_freeCamId, HdCameraTokens->projection,
        VtValue(HdCamera::Perspective));
    _delegate.SetParameter(_freeCamId, HdCameraTokens->horizontalAperture,
        VtValue(float(GfCamera::DEFAULT_HORIZONTAL_APERTURE / GfCamera::APERTURE_UNIT)));
    _delegate.SetParameter(_freeCamId, HdCameraTokens->verticalAperture,
        VtValue(float(GfCamera::DEFAULT_VERTICAL_APERTURE / GfCamera::APERTURE_UNIT)));
    _delegate.SetParameter(_freeCamId, HdCameraTokens->horizontalApertureOffset,
        VtValue(0.0f));
    _delegate.SetParameter(_freeCamId, HdCameraTokens->verticalApertureOffset,
        VtValue(0.0f));
    _delegate.SetParameter(_freeCamId, HdCameraTokens->focalLength,
        VtValue(5.0f));
    _delegate.SetParameter(_freeCamId, HdCameraTokens->clippingRange,
        VtValue(GfRange1f(1.0f, 1000000.0f)));
    _delegate.SetParameter(_freeCamId, HdCameraTokens->clipPlanes,
        VtValue(std::vector<GfVec4d>()));
}

SdfPath
HdxTaskController::_GetRenderTaskPath(TfToken const& materialTag) const
{
    std::string str = TfStringPrintf(""renderTask_%s"",
        materialTag.GetText());
    std::replace(str.begin(), str.end(), ':', '_');
    return GetControllerId().AppendChild(TfToken(str));
}

SdfPath
HdxTaskController::_CreateRenderTask(TfToken const& materialTag)
{
    SdfPath taskId = _GetRenderTaskPath(materialTag);

    HdxRenderTaskParams renderParams;
    renderParams.camera = _freeCamId;
    renderParams.viewport = _viewport;
    renderParams.framing = _framing;
    renderParams.overrideWindowPolicy = _overrideWindowPolicy;

    // Set the blend state based on material tag.
    _SetBlendStateForMaterialTag(materialTag, &renderParams);

    HdRprimCollection collection(HdTokens->geometry,
                                 HdReprSelector(HdReprTokens->smoothHull),
                                 /*forcedRepr*/ false,
                                 materialTag);
    collection.SetRootPath(SdfPath::AbsoluteRootPath());

    if (materialTag == HdMaterialTagTokens->defaultMaterialTag || 
        materialTag == HdxMaterialTagTokens->additive ||
        materialTag == HdStMaterialTagTokens->masked ||
        materialTag.IsEmpty()) {
        GetRenderIndex()->InsertTask<HdxRenderTask>(&_delegate, taskId);
    } else if (materialTag == HdxMaterialTagTokens->translucent) {
        GetRenderIndex()->InsertTask<HdxOitRenderTask>(&_delegate, taskId);
    } else if (materialTag == HdStMaterialTagTokens->volume) {
        GetRenderIndex()->InsertTask<HdxOitVolumeRenderTask>(&_delegate, taskId);
    }

    // Create an initial set of render tags in case the user doesn't set any
    TfTokenVector renderTags = { HdRenderTagTokens->geometry };

    _delegate.SetParameter(taskId, HdTokens->params, renderParams);
    _delegate.SetParameter(taskId, HdTokens->collection, collection);
    _delegate.SetParameter(taskId, HdTokens->renderTags, renderTags);

    return taskId;
}

void
HdxTaskController::_SetBlendStateForMaterialTag(TfToken const& materialTag,
                                        HdxRenderTaskParams *renderParams) const
{
    if (!TF_VERIFY(renderParams)) {
        return;
    }

    if (materialTag == HdxMaterialTagTokens->additive) {
        // Additive blend -- so no sorting of drawItems is needed
        renderParams->blendEnable = true;
        // For color, we are setting all factors to ONE.
        //
        // This means we are expecting pre-multiplied alpha coming out
        // of the shader: vec4(rgb*a, a).  Setting ColorSrc to
        // HdBlendFactorSourceAlpha would give less control on the
        // shader side, since it means we would force a pre-multiplied
        // alpha step on the color coming out of the shader.
        // 
        renderParams->blendColorOp = HdBlendOpAdd;
        renderParams->blendColorSrcFactor = HdBlendFactorOne;
        renderParams->blendColorDstFactor = HdBlendFactorOne;

        // For alpha, we set the factors so that the alpha in the
        // framebuffer won't change.  Recall that the geometry in the
        // additive render pass is supposed to be emitting light but
        // be fully transparent, that is alpha = 0, so that the order
        // in which it is drawn doesn't matter.
        renderParams->blendAlphaOp = HdBlendOpAdd;
        renderParams->blendAlphaSrcFactor = HdBlendFactorZero;
        renderParams->blendAlphaDstFactor = HdBlendFactorOne;

        // Translucent objects should not block each other in depth buffer
        renderParams->depthMaskEnable = false;

        // Since we are using alpha blending, we disable screen door
        // transparency for this renderpass.
        renderParams->enableAlphaToCoverage = false;
    } else if (materialTag == HdxMaterialTagTokens->translucent ||
               materialTag == HdStMaterialTagTokens->volume) {
        // Order Independent Transparency blend state or its first render pass.
        renderParams->blendEnable = false;
        renderParams->enableAlphaToCoverage = false;
        renderParams->depthMaskEnable = false;
    } else if (materialTag == HdStMaterialTagTokens->masked) {
        renderParams->blendEnable = false;
        renderParams->depthMaskEnable = true;
        renderParams->enableAlphaToCoverage = true;
    } else {
        renderParams->blendEnable = false;
        renderParams->depthMaskEnable = true;
        renderParams->enableAlphaToCoverage = false;
    }
}

void
HdxTaskController::_CreateOitResolveTask()
{
    _oitResolveTaskId = GetControllerId().AppendChild(_tokens->oitResolveTask);

    GetRenderIndex()->InsertTask<HdxOitResolveTask>(&_delegate,
        _oitResolveTaskId);
}

void
HdxTaskController::_CreateSelectionTask()
{
    // Create a selection highlighting task.
    _selectionTaskId = GetControllerId().AppendChild(_tokens->selectionTask);

    HdxSelectionTaskParams selectionParams;
    selectionParams.enableSelection = true;
    selectionParams.selectionColor = GfVec4f(1,1,0,1);
    selectionParams.locateColor = GfVec4f(0,0,1,1);

    GetRenderIndex()->InsertTask<HdxSelectionTask>(&_delegate,
        _selectionTaskId);

    _delegate.SetParameter(_selectionTaskId, HdTokens->params,
        selectionParams);
}

void
HdxTaskController::_CreateColorizeSelectionTask()
{
    // Create a post-process selection highlighting task.
    _colorizeSelectionTaskId = GetControllerId().AppendChild(
        _tokens->colorizeSelectionTask);

    HdxColorizeSelectionTaskParams selectionParams;
    selectionParams.enableSelection = true;
    selectionParams.selectionColor = GfVec4f(1,1,0,1);
    selectionParams.locateColor = GfVec4f(0,0,1,1);

    GetRenderIndex()->InsertTask<HdxColorizeSelectionTask>(&_delegate,
        _colorizeSelectionTaskId);

    _delegate.SetParameter(_colorizeSelectionTaskId, HdTokens->params,
        selectionParams);
}

void
HdxTaskController::_CreateLightingTask()
{
    // Simple lighting task uses lighting state from Sprims.
    _simpleLightTaskId = GetControllerId().AppendChild(
        _tokens->simpleLightTask);

    HdxSimpleLightTaskParams simpleLightParams;
    simpleLightParams.cameraPath = _freeCamId;

    GetRenderIndex()->InsertTask<HdxSimpleLightTask>(&_delegate,
        _simpleLightTaskId);

    _delegate.SetParameter(_simpleLightTaskId, HdTokens->params,
        simpleLightParams);
}

void
HdxTaskController::_CreateShadowTask() 
{
    _shadowTaskId = GetControllerId().AppendChild(_tokens->shadowTask);

    HdxShadowTaskParams shadowParams;
    shadowParams.camera = _freeCamId;

    GetRenderIndex()->InsertTask<HdxShadowTask>(&_delegate, _shadowTaskId);

    TfTokenVector renderTags = { HdRenderTagTokens->geometry };

    _delegate.SetParameter(_shadowTaskId, HdTokens->params, shadowParams);
    _delegate.SetParameter(_shadowTaskId, _tokens->renderTags, renderTags);
}

void
HdxTaskController::_CreateColorCorrectionTask()
{
    _colorCorrectionTaskId = GetControllerId().AppendChild(
        _tokens->colorCorrectionTask);

    HdxColorCorrectionTaskParams taskParams;

    GetRenderIndex()->InsertTask<HdxColorCorrectionTask>(&_delegate,
        _colorCorrectionTaskId);

    _delegate.SetParameter(_colorCorrectionTaskId, HdTokens->params,
        taskParams);
}

void
HdxTaskController::_CreatePickTask()
{
    _pickTaskId = GetControllerId().AppendChild(
        _tokens->pickTask);

    HdxPickTaskParams taskParams;

    GetRenderIndex()->InsertTask<HdxPickTask>(&_delegate, _pickTaskId);

    _delegate.SetParameter(_pickTaskId, HdTokens->params, taskParams);
}

void
HdxTaskController::_CreatePickFromRenderBufferTask()
{
    _pickFromRenderBufferTaskId = GetControllerId().AppendChild(
        _tokens->pickFromRenderBufferTask);

    HdxPickFromRenderBufferTaskParams taskParams;
    taskParams.cameraId = _freeCamId;

    GetRenderIndex()->InsertTask<HdxPickFromRenderBufferTask>(&_delegate,
        _pickFromRenderBufferTaskId);

    _delegate.SetParameter(_pickFromRenderBufferTaskId, HdTokens->params,
        taskParams);
}

void 
HdxTaskController::_CreateAovInputTask()
{
    _aovInputTaskId = GetControllerId().AppendChild(_tokens->aovInputTask);

    HdxAovInputTaskParams taskParams;

    GetRenderIndex()->InsertTask<HdxAovInputTask>(&_delegate,
        _aovInputTaskId);

    _delegate.SetParameter(_aovInputTaskId, HdTokens->params,
        taskParams);   
}

void
HdxTaskController::_CreatePresentTask()
{
    _presentTaskId = GetControllerId().AppendChild(
        _tokens->presentTask);

    HdxPresentTaskParams taskParams;

    GetRenderIndex()->InsertTask<HdxPresentTask>(&_delegate,
        _presentTaskId);

    _delegate.SetParameter(_presentTaskId, HdTokens->params,
        taskParams);
}

bool
HdxTaskController::_ShadowsEnabled() const
{
    if (_simpleLightTaskId.IsEmpty())
        return false;

    const HdxSimpleLightTaskParams& simpleLightParams =
        _delegate.GetParameter<HdxSimpleLightTaskParams>(
                _simpleLightTaskId, HdTokens->params);

    // Only enable the shadow task (which renders shadow maps) if shadows are
    // enabled.
    return simpleLightParams.enableShadows;
}

bool
HdxTaskController::_SelectionEnabled() const
{
    if (_renderTaskIds.empty())
        return false;

    const HdxRenderTaskParams& renderTaskParams =
        _delegate.GetParameter<HdxRenderTaskParams>(
            _renderTaskIds.front(), HdTokens->params);

    // Disable selection highlighting when we're rendering ID buffers.
    return !renderTaskParams.enableIdRender;
}

bool
HdxTaskController::_ColorizeSelectionEnabled() const
{
    if (_viewportAov == HdAovTokens->color) {
        return true;
    }
    return false;
}

bool
HdxTaskController::_ColorCorrectionEnabled() const
{
    if (_colorCorrectionTaskId.IsEmpty())
        return false;

    const HdxColorCorrectionTaskParams& colorCorrectionParams =
        _delegate.GetParameter<HdxColorCorrectionTaskParams>(
            _colorCorrectionTaskId, HdTokens->params);

    bool useColorCorrect = colorCorrectionParams.colorCorrectionMode != 
                           HdxColorCorrectionTokens->disabled &&
                           !colorCorrectionParams.colorCorrectionMode.IsEmpty();
    return useColorCorrect;
}

bool
HdxTaskController::_AovsSupported() const
{
    return GetRenderIndex()->IsBprimTypeSupported(
        HdPrimTypeTokens->renderBuffer);
}

bool
HdxTaskController::_CamerasSupported() const
{
    return GetRenderIndex()->IsSprimTypeSupported(
        HdPrimTypeTokens->camera);
}

bool
HdxTaskController::_UsingAovs() const
{
    return !_aovBufferIds.empty();
}

HdTaskSharedPtrVector const
HdxTaskController::GetRenderingTasks() const
{
    HdTaskSharedPtrVector tasks;

    /* The superset of tasks we can run, in order, is:
     * - simpleLightTaskId
     * - shadowTaskId
     * - renderTaskIds (There may be more than one)
     * - aovInputTaskId
     * - selectionTaskId
     * - colorizeSelectionTaskId
     * - colorCorrectionTaskId
     * - colorChannelTaskId
     * - PresentTask
     *
     * Some of these won't be populated, based on the backend type.
     * Additionally, shadow, selection, color correction and color channel can
     * be conditionally disabled.
     *
     * See _CreateRenderGraph for more details.
     */

    if (!_simpleLightTaskId.IsEmpty()) {
        tasks.push_back(GetRenderIndex()->GetTask(_simpleLightTaskId));
    }

    if (!_shadowTaskId.IsEmpty() && _ShadowsEnabled()) {
        tasks.push_back(GetRenderIndex()->GetTask(_shadowTaskId));
    }

    // Perform draw calls
    if (!_renderTaskIds.empty()) {
        SdfPath volumeId = _GetRenderTaskPath(HdStMaterialTagTokens->volume);

        // Render opaque prims, additive and translucent blended prims.
        // Skip volume prims, because volume rendering reads from the depth
        // buffer so we must resolve depth first first.
        for (SdfPath const& id : _renderTaskIds) {
            if (id != volumeId) {
                tasks.push_back(GetRenderIndex()->GetTask(id));
            }
        }

        // Take the aov results from the render tasks, resolve the multisample
        // images and put the results into gpu textures onto shared context.
        if (!_aovInputTaskId.IsEmpty()) {
            tasks.push_back(GetRenderIndex()->GetTask(_aovInputTaskId));
        }

        // Render volume prims
        if (std::find(_renderTaskIds.begin(), _renderTaskIds.end(), volumeId) 
                != _renderTaskIds.end()) {
            tasks.push_back(GetRenderIndex()->GetTask(volumeId));
        }
    }

    // Merge translucent and volume pixels into color target
    if (!_oitResolveTaskId.IsEmpty()) {
        tasks.push_back(GetRenderIndex()->GetTask(_oitResolveTaskId));
    }

    if (!_selectionTaskId.IsEmpty() && _SelectionEnabled()) {
        tasks.push_back(GetRenderIndex()->GetTask(_selectionTaskId));
    }

    if (!_colorizeSelectionTaskId.IsEmpty() && _ColorizeSelectionEnabled()) {
        tasks.push_back(GetRenderIndex()->GetTask(_colorizeSelectionTaskId));
    }

    // Apply color correction / grading (convert to display colors)
    if (_ColorCorrectionEnabled()) {
        tasks.push_back(GetRenderIndex()->GetTask(_colorCorrectionTaskId));
    }

    // Render pixels to screen
    if (!_presentTaskId.IsEmpty()) {
        tasks.push_back(GetRenderIndex()->GetTask(_presentTaskId));
    }

    return tasks;
}

HdTaskSharedPtrVector const
HdxTaskController::GetPickingTasks() const
{
    HdTaskSharedPtrVector tasks;
    if (!_pickTaskId.IsEmpty())
        tasks.push_back(GetRenderIndex()->GetTask(_pickTaskId));
    if (!_pickFromRenderBufferTaskId.IsEmpty())
        tasks.push_back(GetRenderIndex()->GetTask(_pickFromRenderBufferTaskId));

    return tasks;
}

SdfPath
HdxTaskController::_GetAovPath(TfToken const& aov) const
{
    std::string identifier = std::string(""aov_"") +
        TfMakeValidIdentifier(aov.GetString());
    return GetControllerId().AppendChild(TfToken(identifier));
}

void 
HdxTaskController::_SetParameters(SdfPath const& pathName, 
                                  GlfSimpleLight const& light)
{
    _delegate.SetParameter(pathName, HdTokens->transform,
        VtValue(light.GetTransform()));
    _delegate.SetParameter(pathName, HdLightTokens->shadowParams,
        HdxShadowParams());
    _delegate.SetParameter(pathName, HdLightTokens->shadowCollection,
        VtValue());
    _delegate.SetParameter(pathName, HdLightTokens->params,
        light);

    // if we are setting the parameters for the dome light we need to add the 
    // default dome light texture resource.
    if (light.IsDomeLight()) {
        _delegate.SetParameter(pathName, HdLightTokens->textureFile,
                               SdfAssetPath(
                                   HdxPackageDefaultDomeLightTexture(),
                                   HdxPackageDefaultDomeLightTexture()));
    }
}

GlfSimpleLight
HdxTaskController::_GetLightAtId(size_t const& pathIdx)
{
    GlfSimpleLight light = GlfSimpleLight();
    if (pathIdx < _lightIds.size()) {
        light = _delegate.GetParameter<GlfSimpleLight>(
            _lightIds[pathIdx], HdLightTokens->params);
    }
    return light;
}

void 
HdxTaskController::_RemoveLightSprim(size_t const& pathIdx)
{
    if (pathIdx < _lightIds.size()) {
        GetRenderIndex()->RemoveSprim(HdPrimTypeTokens->simpleLight, 
                        _lightIds[pathIdx]);
        GetRenderIndex()->RemoveSprim(HdPrimTypeTokens->domeLight, 
                        _lightIds[pathIdx]);
    }
}

void 
HdxTaskController::_ReplaceLightSprim(size_t const& pathIdx, 
                        GlfSimpleLight const& light, SdfPath const& pathName)
{                
    _RemoveLightSprim(pathIdx);
    if (light.IsDomeLight()) {
        GetRenderIndex()->InsertSprim(HdPrimTypeTokens->domeLight,
                        &_delegate, pathName);
    }
    else {
        GetRenderIndex()->InsertSprim(HdPrimTypeTokens->simpleLight,
                            &_delegate, pathName);
    }
    // set the parameters for lights[i] and mark as dirty
    _SetParameters(pathName, light);            
    GetRenderIndex()->GetChangeTracker().MarkSprimDirty(pathName, 
                                                HdLight::AllDirty);

}

void
HdxTaskController::SetRenderOutputs(TfTokenVector const& outputs)
{
    if (!_AovsSupported() || _renderTaskIds.empty()) {
        return;
    }

    if (_aovOutputs == outputs) {
        return;
    }
    _aovOutputs = outputs;

    TfTokenVector localOutputs = outputs;

    // When we're asked to render ""color"", we treat that as final color,
    // complete with depth-compositing and selection, so we in-line add
    // some extra buffers if they weren't already requested.
    if (_IsStormRenderingBackend(GetRenderIndex())) {
        if (std::find(localOutputs.begin(), 
                      localOutputs.end(),
                      HdAovTokens->depth) == localOutputs.end()) {
            localOutputs.push_back(HdAovTokens->depth);
        }
    } else {
        std::set<TfToken> mainRenderTokens;
        for (auto const& aov : outputs) {
            if (aov == HdAovTokens->color || aov == HdAovTokens->depth ||
                aov == HdAovTokens->primId || aov == HdAovTokens->instanceId ||
                aov == HdAovTokens->elementId) {
                mainRenderTokens.insert(aov);
            }
        }
        // For a backend like PrMan/Embree we fill not just the color buffer,
        // but also buffers that are used during picking.
        if (mainRenderTokens.count(HdAovTokens->color) > 0) {
            if (mainRenderTokens.count(HdAovTokens->depth) == 0) {
                localOutputs.push_back(HdAovTokens->depth);
            }
            if (mainRenderTokens.count(HdAovTokens->primId) == 0) {
                localOutputs.push_back(HdAovTokens->primId);
            }
            if (mainRenderTokens.count(HdAovTokens->elementId) == 0) {
                localOutputs.push_back(HdAovTokens->elementId);
            }
            if (mainRenderTokens.count(HdAovTokens->instanceId) == 0) {
                localOutputs.push_back(HdAovTokens->instanceId);
            }
        }
    }

    // Delete the old renderbuffers.
    for (size_t i = 0; i < _aovBufferIds.size(); ++i) {
        GetRenderIndex()->RemoveBprim(HdPrimTypeTokens->renderBuffer,
            _aovBufferIds[i]);
    }
    _aovBufferIds.clear();

    // Get the render buffer dimensions.
    const GfVec2i dimensions =
        _renderBufferSize != GfVec2i(0)
            ? _renderBufferSize
            : _ViewportToAovDimensions(_viewport);

    const GfVec3i dimensions3(dimensions[0], dimensions[1], 1);

    // Get default AOV descriptors from the render delegate.
    HdAovDescriptorList outputDescs;
    outputDescs.resize(localOutputs.size());
    for (size_t i = 0; i < localOutputs.size(); ++i) {
        outputDescs[i] = GetRenderIndex()->GetRenderDelegate()->
            GetDefaultAovDescriptor(localOutputs[i]);
    }

    // Add the new renderbuffers. _GetAovPath returns ids of the form
    // {controller_id}/aov_{name}.
    for (size_t i = 0; i < localOutputs.size(); ++i) {
        SdfPath aovId = _GetAovPath(localOutputs[i]);
        GetRenderIndex()->InsertBprim(HdPrimTypeTokens->renderBuffer,
            &_delegate, aovId);
        HdRenderBufferDescriptor desc;
        desc.dimensions = dimensions3;
        desc.format = outputDescs[i].format;
        desc.multiSampled = outputDescs[i].multiSampled;
        _delegate.SetParameter(aovId, _tokens->renderBufferDescriptor,desc);
        GetRenderIndex()->GetChangeTracker().MarkBprimDirty(aovId,
            HdRenderBuffer::DirtyDescription);
        _aovBufferIds.push_back(aovId);
    }

    // Create the list of AOV bindings.
    // Only the first render task clears AOVs so we also have a bindings set
    // that specifies no clear color for the remaining render tasks.
    HdRenderPassAovBindingVector aovBindingsClear;
    HdRenderPassAovBindingVector aovBindingsNoClear;
    aovBindingsClear.resize(localOutputs.size());
    aovBindingsNoClear.resize(aovBindingsClear.size());

    for (size_t i = 0; i < localOutputs.size(); ++i) {
        aovBindingsClear[i].aovName = localOutputs[i];
        aovBindingsClear[i].clearValue = outputDescs[i].clearValue;
        aovBindingsClear[i].renderBufferId = _GetAovPath(localOutputs[i]);
        aovBindingsClear[i].aovSettings = outputDescs[i].aovSettings;

        aovBindingsNoClear[i] = aovBindingsClear[i];
        aovBindingsNoClear[i].clearValue = VtValue();
    }

    // Set AOV bindings on render tasks
    for (SdfPath const& renderTaskId : _renderTaskIds) {
        bool isFirstRenderTask = renderTaskId == _renderTaskIds.front();

        const HdRenderPassAovBindingVector& aovBindings = 
            isFirstRenderTask ? 
            aovBindingsClear : 
            aovBindingsNoClear;

        HdxRenderTaskParams rParams =
            _delegate.GetParameter<HdxRenderTaskParams>(renderTaskId,
                HdTokens->params);

        rParams.aovBindings = aovBindings;

        _delegate.SetParameter(renderTaskId, HdTokens->params, rParams);
        GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
            renderTaskId, HdChangeTracker::DirtyParams);
    }

    // For AOV visualization, if only one output was specified, send it
    // to the viewer; otherwise, disable colorization.
    if (outputs.size() == 1) {
        SetViewportRenderOutput(outputs[0]);
    } else {
        SetViewportRenderOutput(TfToken());
    }

    // XXX: The viewport data plumbed to tasks unfortunately depends on whether
    // aovs are being used.
    _SetCameraFramingForTasks();
}

void
HdxTaskController::SetViewportRenderOutput(TfToken const& name)
{
    if (!_AovsSupported()) {
        return;
    }

    if (_viewportAov == name) {
        return;
    }
    _viewportAov = name;

    if (!_aovInputTaskId.IsEmpty()) {
        HdxAovInputTaskParams params;
        if (name.IsEmpty()) {
            params.aovBufferPath = SdfPath::EmptyPath();
            params.depthBufferPath = SdfPath::EmptyPath();
        } else if (name == HdAovTokens->color) {
            params.aovBufferPath = _GetAovPath(HdAovTokens->color);
            params.depthBufferPath = _GetAovPath(HdAovTokens->depth);
        } else {
            params.aovBufferPath = _GetAovPath(name);
            params.depthBufferPath = SdfPath::EmptyPath();
        }

        _delegate.SetParameter(_aovInputTaskId, HdTokens->params, params);
        GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
            _aovInputTaskId, HdChangeTracker::DirtyParams);
    }

    if (!_colorizeSelectionTaskId.IsEmpty()) {
        HdxColorizeSelectionTaskParams selParams =
            _delegate.GetParameter<HdxColorizeSelectionTaskParams>(
                _colorizeSelectionTaskId, HdTokens->params);

        if (name == HdAovTokens->color) {
            // If we're rendering color, make sure the colorize selection task
            // has the proper id buffers...
            selParams.primIdBufferPath =
                _GetAovPath(HdAovTokens->primId);
            selParams.instanceIdBufferPath =
                _GetAovPath(HdAovTokens->instanceId);
            selParams.elementIdBufferPath =
                _GetAovPath(HdAovTokens->elementId);
        } else {
            // Otherwise, clear the colorize selection task out.
            selParams.primIdBufferPath = SdfPath::EmptyPath();
            selParams.instanceIdBufferPath = SdfPath::EmptyPath();
            selParams.elementIdBufferPath = SdfPath::EmptyPath();
        }

        _delegate.SetParameter(_colorizeSelectionTaskId, HdTokens->params,
            selParams);
        GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
            _colorizeSelectionTaskId, HdChangeTracker::DirtyParams);
    }

    if (!_pickFromRenderBufferTaskId.IsEmpty()) {
        HdxPickFromRenderBufferTaskParams pickParams =
            _delegate.GetParameter<HdxPickFromRenderBufferTaskParams>(
                _pickFromRenderBufferTaskId, HdTokens->params);

        if (name == HdAovTokens->color) {
            // If we're rendering color, make sure the pick task has the
            // proper id & depth buffers...
            pickParams.primIdBufferPath =
                _GetAovPath(HdAovTokens->primId);
            pickParams.instanceIdBufferPath =
                _GetAovPath(HdAovTokens->instanceId);
            pickParams.elementIdBufferPath =
                _GetAovPath(HdAovTokens->elementId);
            pickParams.depthBufferPath =
                _GetAovPath(HdAovTokens->depth);
        } else {
            pickParams.primIdBufferPath = SdfPath::EmptyPath();
            pickParams.instanceIdBufferPath = SdfPath::EmptyPath();
            pickParams.elementIdBufferPath = SdfPath::EmptyPath();
            pickParams.depthBufferPath = SdfPath::EmptyPath();
        }

        _delegate.SetParameter(_pickFromRenderBufferTaskId, HdTokens->params,
            pickParams);
        GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
            _pickFromRenderBufferTaskId, HdChangeTracker::DirtyParams);
    }

    if (!_colorCorrectionTaskId.IsEmpty()) {
        HdxColorCorrectionTaskParams colCorParams =
            _delegate.GetParameter<HdxColorCorrectionTaskParams>(
                _colorCorrectionTaskId, HdTokens->params);

        colCorParams.aovName = name;

        _delegate.SetParameter(_colorCorrectionTaskId, HdTokens->params,
            colCorParams);
        GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
            _colorCorrectionTaskId, HdChangeTracker::DirtyParams);
    }

    if (!_presentTaskId.IsEmpty()) {
        HdxPresentTaskParams params =
            _delegate.GetParameter<HdxPresentTaskParams>(
                _presentTaskId, HdTokens->params);

        _delegate.SetParameter(_presentTaskId, HdTokens->params, params);
        GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
            _presentTaskId, HdChangeTracker::DirtyParams);
    }
}

HdRenderBuffer*
HdxTaskController::GetRenderOutput(TfToken const& name)
{
    if (!_AovsSupported()) {
        return nullptr;
    }

    SdfPath renderBufferId = _GetAovPath(name);
    return static_cast<HdRenderBuffer*>(
        GetRenderIndex()->GetBprim(HdPrimTypeTokens->renderBuffer,
            renderBufferId));
}

void
HdxTaskController::SetRenderOutputSettings(TfToken const& name,
                                           HdAovDescriptor const& desc)
{
    if (!_AovsSupported() || _renderTaskIds.empty()) {
        return;
    }

    // Check if we're setting a value for a nonexistent AOV.
    SdfPath renderBufferId = _GetAovPath(name);
    if (!_delegate.HasParameter(renderBufferId,
                                _tokens->renderBufferDescriptor)) {
        TF_WARN(""Render output %s doesn't exist"", name.GetText());
        return;
    }

    // HdAovDescriptor contains data for both the renderbuffer descriptor,
    // and the renderpass aov binding.  Update them both.
    HdRenderBufferDescriptor rbDesc =
        _delegate.GetParameter<HdRenderBufferDescriptor>(renderBufferId,
            _tokens->renderBufferDescriptor);

    if (rbDesc.format != desc.format ||
        rbDesc.multiSampled != desc.multiSampled) {

        rbDesc.format = desc.format;
        rbDesc.multiSampled = desc.multiSampled;
        _delegate.SetParameter(renderBufferId,
            _tokens->renderBufferDescriptor, rbDesc);
        GetRenderIndex()->GetChangeTracker().MarkBprimDirty(renderBufferId,
            HdRenderBuffer::DirtyDescription);
    }

    for (SdfPath const& renderTaskId : _renderTaskIds) {
        HdxRenderTaskParams renderParams =
            _delegate.GetParameter<HdxRenderTaskParams>(
                renderTaskId, HdTokens->params);

        bool isFirstRenderTask = renderTaskId == _renderTaskIds.front();

        for (size_t i = 0; i < renderParams.aovBindings.size(); ++i) {
            if (renderParams.aovBindings[i].renderBufferId == renderBufferId) {
                if (renderParams.aovBindings[i].clearValue != desc.clearValue ||
                    renderParams.aovBindings[i].aovSettings != desc.aovSettings) 
                {
                    // Only the first RenderTask should clear the AOV
                    renderParams.aovBindings[i].clearValue = isFirstRenderTask ?
                        desc.clearValue : VtValue();

                    renderParams.aovBindings[i].aovSettings = desc.aovSettings;
                    _delegate.SetParameter(renderTaskId, HdTokens->params,
                        renderParams);
                    GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
                        renderTaskId, HdChangeTracker::DirtyParams);
                }
                break;
            }
        }
    }
}

HdAovDescriptor
HdxTaskController::GetRenderOutputSettings(TfToken const& name) const
{
    if (!_AovsSupported() || _renderTaskIds.empty()) {
        return HdAovDescriptor();
    }

    // Check if we're getting a value for a nonexistent AOV.
    SdfPath renderBufferId = _GetAovPath(name);
    if (!_delegate.HasParameter(renderBufferId,
                                _tokens->renderBufferDescriptor)) {
        return HdAovDescriptor();
    }

    HdRenderBufferDescriptor rbDesc =
        _delegate.GetParameter<HdRenderBufferDescriptor>(renderBufferId,
            _tokens->renderBufferDescriptor);

    HdAovDescriptor desc;
    desc.format = rbDesc.format;
    desc.multiSampled = rbDesc.multiSampled;

    const SdfPath& renderTaskId = _renderTaskIds.front();

    HdxRenderTaskParams renderParams =
        _delegate.GetParameter<HdxRenderTaskParams>(
            renderTaskId, HdTokens->params);

    for (size_t i = 0; i < renderParams.aovBindings.size(); ++i) {
        if (renderParams.aovBindings[i].renderBufferId == renderBufferId) {
            desc.clearValue = renderParams.aovBindings[i].clearValue;
            desc.aovSettings = renderParams.aovBindings[i].aovSettings;
            break;
        }
    }

    return desc;
}


void
HdxTaskController::SetCollection(HdRprimCollection const& collection)
{
    // XXX For now we assume the application calling to set a new
    //     collection does not know or setup the material tags and does not
    //     split up the collection according to material tags.
    //     In order to ignore materialTags when comparing collections we need
    //     to copy the old tag into the new collection. Since the provided
    //     collection is const, we need to make a not-ideal copy.
    HdRprimCollection newCollection = collection;

    for (SdfPath const& renderTaskId : _renderTaskIds) {
        HdRprimCollection oldCollection =
            _delegate.GetParameter<HdRprimCollection>(
                renderTaskId, HdTokens->collection);

        TfToken const& oldMaterialTag = oldCollection.GetMaterialTag();
        newCollection.SetMaterialTag(oldMaterialTag);

        if (oldCollection == newCollection) {
            continue;
        }

        _delegate.SetParameter(renderTaskId, HdTokens->collection, 
                               newCollection);
        GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
            renderTaskId, HdChangeTracker::DirtyCollection);
    }
}

void
HdxTaskController::SetRenderParams(HdxRenderTaskParams const& params)
{
    for (SdfPath const& renderTaskId : _renderTaskIds) {
        HdRprimCollection collection =
            _delegate.GetParameter<HdRprimCollection>(
                renderTaskId, HdTokens->collection);

        HdxRenderTaskParams oldParams = 
            _delegate.GetParameter<HdxRenderTaskParams>(
                renderTaskId, HdTokens->params);

        // We explicitly ignore input camera, viewport, and aovBindings because
        // these are internally managed.
        HdxRenderTaskParams mergedParams = params;
        mergedParams.camera = oldParams.camera;
        mergedParams.viewport = oldParams.viewport;
        mergedParams.framing = oldParams.framing;
        mergedParams.overrideWindowPolicy = oldParams.overrideWindowPolicy;
        mergedParams.aovBindings = oldParams.aovBindings;

        // We also explicitly manage blend params, based on the material tag.
        // XXX: Note: if params.enableIdRender is set, we want to use default
        // blend params so that we don't try to additive blend ID buffers...
        _SetBlendStateForMaterialTag(
            params.enableIdRender ? TfToken() : collection.GetMaterialTag(),
            &mergedParams);

        if (mergedParams != oldParams) {
            _delegate.SetParameter(renderTaskId,
                HdTokens->params, mergedParams);
            GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
                renderTaskId, HdChangeTracker::DirtyParams);
        }
    }

    // Update shadow task in case materials have been enabled/disabled
    if (!_shadowTaskId.IsEmpty()) {
        HdxShadowTaskParams oldShParams = 
            _delegate.GetParameter<HdxShadowTaskParams>(
                _shadowTaskId, HdTokens->params);

        if (oldShParams.enableSceneMaterials != params.enableSceneMaterials) {
            oldShParams.enableSceneMaterials = params.enableSceneMaterials;
            _delegate.SetParameter(_shadowTaskId, 
                HdTokens->params, oldShParams);
            GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
                _shadowTaskId, HdChangeTracker::DirtyParams);
        }
    }

    // Update pick task
    if (!_pickTaskId.IsEmpty()) {
        HdxPickTaskParams pickParams =
            _delegate.GetParameter<HdxPickTaskParams>(
                _pickTaskId, HdTokens->params);
        
        if (pickParams.cullStyle != params.cullStyle ||
            pickParams.enableSceneMaterials != params.enableSceneMaterials) {

            pickParams.cullStyle = params.cullStyle;
            pickParams.enableSceneMaterials = params.enableSceneMaterials;

            _delegate.SetParameter(_pickTaskId, HdTokens->params, pickParams);
            GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
                _pickTaskId, HdChangeTracker::DirtyParams);
        }
    }
}


void
HdxTaskController::SetRenderTags(TfTokenVector const& renderTags)
{
    HdChangeTracker &tracker = GetRenderIndex()->GetChangeTracker();

    for (SdfPath const& renderTaskId : _renderTaskIds) {
        if (_delegate.GetTaskRenderTags(renderTaskId) != renderTags) {
            _delegate.SetParameter(renderTaskId,
                                   _tokens->renderTags,
                                   renderTags);
            tracker.MarkTaskDirty(renderTaskId,
                                  HdChangeTracker::DirtyRenderTags);
        }
    }

    if (!_pickTaskId.IsEmpty()) {
        if (_delegate.GetTaskRenderTags(_pickTaskId) != renderTags) {
            _delegate.SetParameter(_pickTaskId,
                                   _tokens->renderTags,
                                   renderTags);

            tracker.MarkTaskDirty(_pickTaskId,
                                  HdChangeTracker::DirtyRenderTags);
        }
    }
}


void
HdxTaskController::SetShadowParams(HdxShadowTaskParams const& params)
{
    if (_shadowTaskId.IsEmpty()) {
        return;
    }

    HdxShadowTaskParams oldParams = 
        _delegate.GetParameter<HdxShadowTaskParams>(
            _shadowTaskId, HdTokens->params);

    HdxShadowTaskParams mergedParams = params;
    mergedParams.camera = oldParams.camera;
    mergedParams.viewport = oldParams.viewport;
    mergedParams.enableSceneMaterials = oldParams.enableSceneMaterials;

    if (mergedParams != oldParams) {
        _delegate.SetParameter(_shadowTaskId, HdTokens->params, mergedParams);
        GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
            _shadowTaskId, HdChangeTracker::DirtyParams);
    }
}

void
HdxTaskController::SetEnableShadows(bool enable)
{
    if (_simpleLightTaskId.IsEmpty()) {
        return;
    }

    HdxSimpleLightTaskParams params =
        _delegate.GetParameter<HdxSimpleLightTaskParams>(
            _simpleLightTaskId, HdTokens->params);

    if (params.enableShadows != enable) {
        params.enableShadows = enable;
        _delegate.SetParameter(_simpleLightTaskId, HdTokens->params, params);
        GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
            _simpleLightTaskId, HdChangeTracker::DirtyParams);
    }
}

void
HdxTaskController::SetEnableSelection(bool enable)
{
    if (!_selectionTaskId.IsEmpty()) {
        HdxSelectionTaskParams params =
            _delegate.GetParameter<HdxSelectionTaskParams>(
                _selectionTaskId, HdTokens->params);

        if (params.enableSelection != enable) {
            params.enableSelection = enable;
            _delegate.SetParameter(_selectionTaskId,
                HdTokens->params, params);
            GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
                _selectionTaskId, HdChangeTracker::DirtyParams);
        }
    }

    if (!_colorizeSelectionTaskId.IsEmpty()) {
        HdxColorizeSelectionTaskParams params =
            _delegate.GetParameter<HdxColorizeSelectionTaskParams>(
                _colorizeSelectionTaskId, HdTokens->params);

        if (params.enableSelection != enable) {
            params.enableSelection = enable;
            _delegate.SetParameter(_colorizeSelectionTaskId,
                HdTokens->params, params);
            GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
                _colorizeSelectionTaskId, HdChangeTracker::DirtyParams);
        }
    }
}

void
HdxTaskController::SetSelectionColor(GfVec4f const& color)
{
    if (!_selectionTaskId.IsEmpty()) {
        HdxSelectionTaskParams params =
            _delegate.GetParameter<HdxSelectionTaskParams>(
                _selectionTaskId, HdTokens->params);

        if (params.selectionColor != color) {
            params.selectionColor = color;
            _delegate.SetParameter(_selectionTaskId,
                HdTokens->params, params);
            GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
                _selectionTaskId, HdChangeTracker::DirtyParams);
        }
    }

    if (!_colorizeSelectionTaskId.IsEmpty()) {
        HdxColorizeSelectionTaskParams params =
            _delegate.GetParameter<HdxColorizeSelectionTaskParams>(
                _colorizeSelectionTaskId, HdTokens->params);

        if (params.selectionColor != color) {
            params.selectionColor = color;
            _delegate.SetParameter(_colorizeSelectionTaskId,
                HdTokens->params, params);
            GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
                _colorizeSelectionTaskId, HdChangeTracker::DirtyParams);
        }
    }
}

void
HdxTaskController::SetSelectionEnableOutline(bool enableOutline)
{
    if (!_colorizeSelectionTaskId.IsEmpty()) {
        HdxColorizeSelectionTaskParams params =
            _delegate.GetParameter<HdxColorizeSelectionTaskParams>(
                _colorizeSelectionTaskId, HdTokens->params);

        if (params.enableOutline != enableOutline) {
            params.enableOutline = enableOutline;
            _delegate.SetParameter(_colorizeSelectionTaskId,
                HdTokens->params, params);
            GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
                _colorizeSelectionTaskId, HdChangeTracker::DirtyParams);
        }
    }
}

void
HdxTaskController::SetSelectionOutlineRadius(unsigned int radius)
{
    if (!_colorizeSelectionTaskId.IsEmpty()) {
        HdxColorizeSelectionTaskParams params =
            _delegate.GetParameter<HdxColorizeSelectionTaskParams>(
                _colorizeSelectionTaskId, HdTokens->params);

        if (params.outlineRadius != radius) {
            params.outlineRadius = radius;
            _delegate.SetParameter(_colorizeSelectionTaskId,
                HdTokens->params, params);
            GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
                _colorizeSelectionTaskId, HdChangeTracker::DirtyParams);
        }
    }
}


void
HdxTaskController::SetLightingState(GlfSimpleLightingContextPtr const& src)
{
    // If simpleLightTask doesn't exist, no need to process the lighting
    // context...
    if (_simpleLightTaskId.IsEmpty()) {
        return;
    }

    if (!src) {
        TF_CODING_ERROR(""Null lighting context"");
        return;
    }

    GlfSimpleLightVector const& lights = src->GetLights();

    // HdxTaskController inserts a set of light prims to represent the lights
    // passed in through the simple lighting context (lights vector). These are 
    // managed by the task controller, and not by the scene; they represent the
    // application state which
    //
    // if we need to add any lights to the _lightIds vector 
    if (_lightIds.size() < lights.size()) {

        // cycle through the lights, add the new light and make sure the Sprims
        // at _lightIds[i] match with what is in lights[i]
        for (size_t i = 0; i < lights.size(); ++i) {
            
            // Get or create the light path for lights[i]
            bool needToAddLightPath = false;
            SdfPath lightPath = SdfPath();            
            if (i >= _lightIds.size()) {
                lightPath = GetControllerId().AppendChild(TfToken(
                            TfStringPrintf(""light%d"", (int)_lightIds.size())));
                needToAddLightPath = true;
            }
            else {
                lightPath = _lightIds[i];
            }
            // make sure that light at _lightIds[i] matches with lights[i]
            GlfSimpleLight currLight = _GetLightAtId(i);
            if (currLight != lights[i]) {

                // replace _lightIds[i] with the appropriate light 
                _ReplaceLightSprim(i, lights[i], lightPath);
            }
            if (needToAddLightPath){
                _lightIds.push_back(lightPath);
            }
        }
    }

    // if we need to remove Ids from the _lightIds vector 
    else if (_lightIds.size() > lights.size()) {

        // cycle through the lights making sure the Sprims at _lightIds[i] 
        // match with what is in lights[i]
        for (size_t i = 0; i < lights.size(); ++i) {
            
            // Get the light path for lights[i]
            SdfPath lightPath = _lightIds[i];
            
            // make sure that light at _lightIds[i] matches with lights[i]
            GlfSimpleLight currLight = _GetLightAtId(i);
            if (currLight != lights[i]) {

                // replace _lightIds[i] with the appropriate light 
                _ReplaceLightSprim(i, lights[i], lightPath);
            }
        }
        // now that everything matches just remove the last item in _lightIds
        _RemoveLightSprim(_lightIds.size()-1);
        _lightIds.pop_back();
    }

    // if there has been no change in the number of lights we still may need to 
    // update the light parameters eg. if the free camera has moved 
    for (size_t i = 0; i < lights.size(); ++i) {
        GlfSimpleLight light = _GetLightAtId(i);
        if (light != lights[i]) {
            _delegate.SetParameter(_lightIds[i], 
                                    HdLightTokens->params, lights[i]);

            if (light.IsDomeLight()) {
                _delegate.SetParameter(
                    _lightIds[i], HdLightTokens->textureFile,
                    SdfAssetPath(
                        HdxPackageDefaultDomeLightTexture(),
                        HdxPackageDefaultDomeLightTexture()));
            }
            GetRenderIndex()->GetChangeTracker().MarkSprimDirty(
                _lightIds[i], HdLight::DirtyParams);
        }
    }

    // In addition to lights, the lighting context contains material parameters.
    // These are passed in through the simple light task's ""params"" field, so
    // we need to update that field if the material parameters changed.
    //
    // It's unfortunate that the lighting context is split this way.
    HdxSimpleLightTaskParams lightParams =
        _delegate.GetParameter<HdxSimpleLightTaskParams>(_simpleLightTaskId,
            HdTokens->params);

    if (lightParams.sceneAmbient != src->GetSceneAmbient() ||
        lightParams.material != src->GetMaterial()) {

        lightParams.sceneAmbient = src->GetSceneAmbient();
        lightParams.material = src->GetMaterial();

        _delegate.SetParameter(
            _simpleLightTaskId, HdTokens->params, lightParams);
        GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
            _simpleLightTaskId, HdChangeTracker::DirtyParams);
    }
}

void
HdxTaskController::SetRenderViewport(GfVec4d const& viewport)
{
    if (_viewport == viewport) {
        return;
    }
    _viewport = viewport;

    // Update the params for tasks that consume viewport info.
    _SetCameraFramingForTasks();
    
    // Update all of the render buffer sizes as well.
    _UpdateAovDimensions(_ViewportToAovDimensions(viewport));
}

void
HdxTaskController::SetRenderBufferSize(const GfVec2i &size)
{
    if (_renderBufferSize == size) {
        return;
    }
    
    _renderBufferSize = size;

    _UpdateAovDimensions(size);
}

void
HdxTaskController::SetFraming(const CameraUtilFraming &framing)
{
    _framing = framing;
    _SetCameraFramingForTasks();
}

void
HdxTaskController::SetOverrideWindowPolicy(
    const std::pair<bool, CameraUtilConformWindowPolicy> &policy)
{
    _overrideWindowPolicy = policy;
    _SetCameraFramingForTasks();
}

void
HdxTaskController::SetCameraPath(SdfPath const& id)
{
    _SetCameraParamForTasks(id);
}

void
HdxTaskController::SetFreeCameraMatrices(GfMatrix4d const& viewMatrix,
                                         GfMatrix4d const& projMatrix)
{
    if (_freeCamId == SdfPath::EmptyPath()) {
        return;
    }

    _SetCameraParamForTasks(_freeCamId);

    GfCamera cam;
    cam.SetFromViewAndProjectionMatrix(viewMatrix, projMatrix);

    const GfMatrix4d &transform = cam.GetTransform();
    if (transform != _delegate.GetParameter<GfMatrix4d>(
            _freeCamId, HdTokens->transform)) {
        // Cache the new view matrix
        _delegate.SetParameter(
            _freeCamId, HdTokens->transform, transform);
        // Invalidate the camera
        GetRenderIndex()->GetChangeTracker().MarkSprimDirty(
            _freeCamId, HdCamera::DirtyTransform);
    }

    const HdCamera::Projection projection =
        cam.GetProjection() == GfCamera::Perspective
            ? HdCamera::Perspective
            : HdCamera::Orthographic;
    if (projection != _delegate.GetParameter<HdCamera::Projection>(
            _freeCamId, HdCameraTokens->projection)) {
        _delegate.SetParameter(
            _freeCamId, HdCameraTokens->projection, projection);
        GetRenderIndex()->GetChangeTracker().MarkSprimDirty(
            _freeCamId, HdCamera::DirtyParams);
    }

    const float focalLength =
        cam.GetFocalLength() * float(GfCamera::FOCAL_LENGTH_UNIT);
    if (focalLength != _delegate.GetParameter<float>(
            _freeCamId, HdCameraTokens->focalLength)) {
        _delegate.SetParameter(
            _freeCamId, HdCameraTokens->focalLength, focalLength);
        GetRenderIndex()->GetChangeTracker().MarkSprimDirty(
            _freeCamId, HdCamera::DirtyParams);
    }

    const float horizontalAperture =
        cam.GetHorizontalAperture() * float(GfCamera::APERTURE_UNIT);
    if (horizontalAperture != _delegate.GetParameter<float>(
            _freeCamId, HdCameraTokens->horizontalAperture)) {
        _delegate.SetParameter(
            _freeCamId, HdCameraTokens->horizontalAperture,
            horizontalAperture);
        GetRenderIndex()->GetChangeTracker().MarkSprimDirty(
            _freeCamId, HdCamera::DirtyParams);
    }

    const float verticalAperture =
        cam.GetVerticalAperture() * float(GfCamera::APERTURE_UNIT);
    if (verticalAperture != _delegate.GetParameter<float>(
            _freeCamId, HdCameraTokens->verticalAperture)) {
        _delegate.SetParameter(
            _freeCamId, HdCameraTokens->verticalAperture,
            verticalAperture);
        GetRenderIndex()->GetChangeTracker().MarkSprimDirty(
            _freeCamId, HdCamera::DirtyParams);
    }

    const float horizontalApertureOffset =
        cam.GetHorizontalApertureOffset() * float(GfCamera::APERTURE_UNIT);
    if (horizontalApertureOffset != _delegate.GetParameter<float>(
            _freeCamId, HdCameraTokens->horizontalApertureOffset)) {
        _delegate.SetParameter(
            _freeCamId, HdCameraTokens->horizontalApertureOffset,
            horizontalApertureOffset);
        GetRenderIndex()->GetChangeTracker().MarkSprimDirty(
            _freeCamId, HdCamera::DirtyParams);
    }

    const float verticalApertureOffset =
        cam.GetVerticalApertureOffset() * float(GfCamera::APERTURE_UNIT);
    if (verticalApertureOffset != _delegate.GetParameter<float>(
            _freeCamId, HdCameraTokens->verticalApertureOffset)) {
        _delegate.SetParameter(
            _freeCamId, HdCameraTokens->verticalApertureOffset,
            verticalApertureOffset);
        GetRenderIndex()->GetChangeTracker().MarkSprimDirty(
            _freeCamId, HdCamera::DirtyParams);
    }

    const GfRange1f &clippingRange = cam.GetClippingRange();
    if (clippingRange != _delegate.GetParameter<GfRange1f>(
            _freeCamId, HdCameraTokens->clippingRange)) {
        _delegate.SetParameter(
            _freeCamId, HdCameraTokens->clippingRange,
            clippingRange);
        GetRenderIndex()->GetChangeTracker().MarkSprimDirty(
            _freeCamId, HdCamera::DirtyParams);
    }
}

void
HdxTaskController::
SetFreeCameraClipPlanes(std::vector<GfVec4d> const& clipPlanes)
{
    if (_freeCamId == SdfPath::EmptyPath()) {
        return;
    }

    // Cache the clip planes
    std::vector<GfVec4d> oldClipPlanes =
        _delegate.GetParameter<std::vector<GfVec4d>>(_freeCamId,
            HdCameraTokens->clipPlanes);

    if (oldClipPlanes != clipPlanes) {
        _delegate.SetParameter(_freeCamId, HdCameraTokens->clipPlanes,
            clipPlanes);
        GetRenderIndex()->GetChangeTracker().MarkSprimDirty(_freeCamId,
            HdCamera::DirtyClipPlanes);
    }
}

bool
HdxTaskController::IsConverged() const
{
    bool converged = true;

    HdTaskSharedPtrVector tasks = GetRenderingTasks();
    for (auto const& task : tasks) {
        std::shared_ptr<HdxTask> progressiveTask =
            std::dynamic_pointer_cast<HdxTask>(task);
        if (progressiveTask) {
            converged = converged && progressiveTask->IsConverged();
            if (!converged) {
                break;
            }
        }
    }

    return converged;
}

void 
HdxTaskController::SetColorCorrectionParams(
    HdxColorCorrectionTaskParams const& params)
{
    if (_colorCorrectionTaskId.IsEmpty()) {
        return;
    }

    HdxColorCorrectionTaskParams oldParams = 
        _delegate.GetParameter<HdxColorCorrectionTaskParams>(
            _colorCorrectionTaskId, HdTokens->params);

    // We assume the caller for SetColorCorrectionParams wants to set the
    // OCIO settings, but does not want to override the AOV used to do color-
    // correction on. (Currently this AOV is controlled via TaskController)
    HdxColorCorrectionTaskParams newParams = params;
    newParams.aovName = oldParams.aovName;

    if (newParams != oldParams) {
        _delegate.SetParameter(
            _colorCorrectionTaskId, HdTokens->params, newParams);

        GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
            _colorCorrectionTaskId, HdChangeTracker::DirtyParams);
    }
}

void 
HdxTaskController::SetEnablePresentation(bool enabled)
{
    HdxPresentTaskParams params =
        _delegate.GetParameter<HdxPresentTaskParams>(
            _presentTaskId, HdTokens->params);

    if (params.enabled != enabled) {
        params.enabled = enabled;
        _delegate.SetParameter(_presentTaskId, HdTokens->params, params);
        GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
            _presentTaskId, HdChangeTracker::DirtyParams);
    }
}

void
HdxTaskController::_SetCameraParamForTasks(SdfPath const& id)
{
    if (_activeCameraId != id) {
        _activeCameraId = id;

        // Update tasks that take a camera task param.
        for (SdfPath const& renderTaskId : _renderTaskIds) {
            HdxRenderTaskParams params =
                _delegate.GetParameter<HdxRenderTaskParams>(
                    renderTaskId, HdTokens->params);
            params.camera = _activeCameraId;

            _delegate.SetParameter(renderTaskId, HdTokens->params, params);
            GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
                renderTaskId, HdChangeTracker::DirtyParams);
        }
        
        if (!_simpleLightTaskId.IsEmpty()) {
            HdxSimpleLightTaskParams params =
                _delegate.GetParameter<HdxSimpleLightTaskParams>(
                    _simpleLightTaskId, HdTokens->params);
            params.cameraPath = _activeCameraId;
            _delegate.SetParameter(_simpleLightTaskId, HdTokens->params,
                                   params);
            GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
                _simpleLightTaskId, HdChangeTracker::DirtyParams);
        }

        if (!_shadowTaskId.IsEmpty()) {
            HdxShadowTaskParams params =
                _delegate.GetParameter<HdxShadowTaskParams>(
                    _shadowTaskId, HdTokens->params);
            params.camera = _activeCameraId;
            _delegate.SetParameter(_shadowTaskId, HdTokens->params, params);
            GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
                _shadowTaskId, HdChangeTracker::DirtyParams);
        }

        if (!_pickFromRenderBufferTaskId.IsEmpty()) {
            HdxPickFromRenderBufferTaskParams params =
                _delegate.GetParameter<HdxPickFromRenderBufferTaskParams>(
                    _pickFromRenderBufferTaskId, HdTokens->params);
            params.cameraId = _activeCameraId;
            _delegate.SetParameter(
                _pickFromRenderBufferTaskId, HdTokens->params, params);
            GetRenderIndex()->GetChangeTracker().MarkTaskDirty(
                _pickFromRenderBufferTaskId, HdChangeTracker::DirtyParams);
        }
    }
}

static
GfVec4i
_ToVec4i(const GfVec4d &v)
{
    return GfVec4i(int(v[0]), int(v[1]), int(v[2]), int(v[3]));
}

void
HdxTaskController::_SetCameraFramingForTasks()
{
    // When aovs are in use, the expectation is that each aov is resized to
    // the non-masked region and we render only the necessary pixels.
    // The composition step (i.e., the present task) uses the viewport
    // offset to update the unmasked region of the bound framebuffer.
    const GfVec4d adjustedViewport =
        _UsingAovs()
            ? GfVec4d(0, 0, _viewport[2], _viewport[3])
            : _viewport;

    HdChangeTracker &changeTracker = GetRenderIndex()->GetChangeTracker();

    for (SdfPath const& renderTaskId : _renderTaskIds) {
        HdxRenderTaskParams params =
            _delegate.GetParameter<HdxRenderTaskParams>(
                renderTaskId, HdTokens->params);

        if (params.viewport != adjustedViewport ||
            params.framing != _framing ||
            params.overrideWindowPolicy != _overrideWindowPolicy) {

            params.framing = _framing;
            params.overrideWindowPolicy = _overrideWindowPolicy;
            params.viewport = adjustedViewport;
            _delegate.SetParameter(renderTaskId, HdTokens->params, params);
            changeTracker.MarkTaskDirty(
                renderTaskId, HdChangeTracker::DirtyParams);
        }
    }

    if (!_shadowTaskId.IsEmpty()) {
        // The shadow and camera viewport should be the same
        // so we don't have to double check what the shadow task has.
        HdxShadowTaskParams params =
            _delegate.GetParameter<HdxShadowTaskParams>(
                _shadowTaskId, HdTokens->params);
        if (params.viewport != adjustedViewport) {
            params.viewport = adjustedViewport;
            _delegate.SetParameter(_shadowTaskId, HdTokens->params, params);
            changeTracker.MarkTaskDirty(
                _shadowTaskId, HdChangeTracker::DirtyParams);
        }
    }

    if (!_pickFromRenderBufferTaskId.IsEmpty()) {
        HdxPickFromRenderBufferTaskParams params =
            _delegate.GetParameter<HdxPickFromRenderBufferTaskParams>(
                _pickFromRenderBufferTaskId, HdTokens->params);
        if (params.viewport != adjustedViewport) {
            params.viewport = adjustedViewport;
            _delegate.SetParameter(
                _pickFromRenderBufferTaskId, HdTokens->params, params);
            changeTracker.MarkTaskDirty(
                _pickFromRenderBufferTaskId, HdChangeTracker::DirtyParams);
        }
    }

    if (!_presentTaskId.IsEmpty()) {
        HdxPresentTaskParams params =
            _delegate.GetParameter<HdxPresentTaskParams>(
                _presentTaskId, HdTokens->params);
        // The composition step uses the viewport passed in by the application,
        // which may have a non-zero offset for things like camera masking.
        const GfVec4i compRegion = 
            _framing.IsValid()
                ? GfVec4i(0, 0, _renderBufferSize[0], _renderBufferSize[1])
                : _ToVec4i(_viewport);

        if (params.compRegion != compRegion) {
            params.compRegion = compRegion;
            _delegate.SetParameter(_presentTaskId, HdTokens->params, params);
            changeTracker.MarkTaskDirty(
                _presentTaskId, HdChangeTracker::DirtyParams);
        }
    }
}

void
HdxTaskController::_UpdateAovDimensions(GfVec2i const& dimensions)
{
    const GfVec3i dimensions3(dimensions[0], dimensions[1], 1);

    HdChangeTracker &changeTracker = GetRenderIndex()->GetChangeTracker();

    for (auto const& id : _aovBufferIds) {
        HdRenderBufferDescriptor desc =
            _delegate.GetParameter<HdRenderBufferDescriptor>(id,
                _tokens->renderBufferDescriptor);
        if (desc.dimensions != dimensions3) {
            desc.dimensions = dimensions3;
            _delegate.SetParameter(id, _tokens->renderBufferDescriptor, desc);
            changeTracker.MarkBprimDirty(id,
                HdRenderBuffer::DirtyDescription);
        }
    }
}


PXR_NAMESPACE_CLOSE_SCOPE
",16214,True,3558.5645166210875,median
"= v1beta1.RoleBinding
{product-author}
{product-version}
:data-uri:
:icons:
:toc: macro
:toc-title:
:toclevels: 2

toc::[]

== Description
[%hardbreaks]
RoleBinding references a role, but does not contain it.  It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in.  RoleBindings in a given namespace only have effect in that namespace.

== Object Schema
Expand or mouse-over a field for more information about it.

++++
<pre>
<div style=""margin-left:13px;""><span title=""(string) APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources"">apiVersion</span>:
</div><div style=""margin-left:13px;""><span title=""(string) Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><details open><summary><span title=""(v1.ObjectMeta) Standard object&#39;s metadata."">metadata</span>:
</summary><details><summary>  <span title=""(object) Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations"">annotations</span>:
</summary><div style=""margin-left:13px;"">    <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) The name of the cluster which the object belongs to. This is used to distinguish resources with same name and namespace in different clusters. This field is not set anywhere right now and apiserver is going to ignore it if set in create or update request."">clusterName</span>:
</div><div style=""margin-left:13px;"">  <span title=""(v1.Time) CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.

Populated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata"">creationTimestamp</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only."">deletionGracePeriodSeconds</span>:
</div><div style=""margin-left:13px;"">  <span title=""(v1.Time) DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.

Populated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata"">deletionTimestamp</span>:
</div><details><summary>  <span title=""(array) Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed."">finalizers</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.

If this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header).

Applied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#idempotency"">generateName</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) A sequence number representing a specific generation of the desired state. Populated by the system. Read-only."">generation</span>:
</div><details><summary>  <span title=""(v1.Initializers) An initializer is a controller which enforces some system invariant at object creation time. This field is a list of initializers that have not yet acted on this object. If nil or empty, this object has been completely initialized. Otherwise, the object is considered uninitialized and is hidden (in list/watch and get calls) from clients that haven&#39;t explicitly asked to observe uninitialized objects.

When an object is created, the system will populate this list with the current set of initializers. Only privileged users may set or modify this list. Once it is empty, it may not be modified further by any user."">initializers</span>:
</summary><details><summary>    <span title=""(array) Pending is a list of initializers that must execute in order before this object is visible. When the last pending initializer is removed, and no failing result is set, the initializers struct will be set to nil and the object is considered as initialized and visible to all clients."">pending</span>:
</summary><div style=""margin-left:13px;"">    - <span title=""(string) name of the process that is responsible for initializing this object."">name</span>:
</div></details><details><summary>    <span title=""(v1.Status) If result is set with the Failure field, the object will be persisted to storage and then deleted, ensuring that other clients can observe the deletion."">result</span>:
</summary><div style=""margin-left:13px;"">      <span title=""(string) APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources"">apiVersion</span>:
</div><div style=""margin-left:13px;"">      <span title=""(integer) Suggested HTTP return code for this status, 0 if not set."">code</span>:
</div><details><summary>      <span title=""(v1.StatusDetails) Extended data associated with the reason.  Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type."">details</span>:
</summary><details><summary>        <span title=""(array) The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes."">causes</span>:
</summary><div style=""margin-left:13px;"">        - <span title=""(string) The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed.  Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.

Examples:
  &#34;name&#34; - the field &#34;name&#34; on the current resource
  &#34;items[0].name&#34; - the field &#34;name&#34; on the first array entry in &#34;items&#34;"">field</span>:
</div><div style=""margin-left:13px;"">          <span title=""(string) A human-readable description of the cause of the error.  This field may be presented as-is to a reader."">message</span>:
</div><div style=""margin-left:13px;"">          <span title=""(string) A machine-readable description of the cause of the error. If this value is empty there is no information available."">reason</span>:
</div></details><div style=""margin-left:13px;"">        <span title=""(string) The group attribute of the resource associated with the status StatusReason."">group</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described)."">name</span>:
</div><div style=""margin-left:13px;"">        <span title=""(integer) If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action."">retryAfterSeconds</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) UID of the resource. (when there is a single resource which can be described). More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><div style=""margin-left:13px;"">      <span title=""(string) Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) A human-readable description of the status of this operation."">message</span>:
</div><details><summary>      <span title=""(v1.ListMeta) Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">metadata</span>:
</summary><div style=""margin-left:13px;"">        <span title=""(string) continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response."">continue</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) String that identifies the server&#39;s internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency"">resourceVersion</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) selfLink is a URL representing this object. Populated by the system. Read-only."">selfLink</span>:
</div></details><div style=""margin-left:13px;"">      <span title=""(string) A machine-readable description of why this operation is in the &#34;Failure&#34; status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it."">reason</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) Status of the operation. One of: &#34;Success&#34; or &#34;Failure&#34;. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status"">status</span>:
</div></details></details><details><summary>  <span title=""(object) Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels"">labels</span>:
</summary><div style=""margin-left:13px;"">    <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names"">name</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Namespace defines the space within each name must be unique. An empty namespace is equivalent to the &#34;default&#34; namespace, but &#34;default&#34; is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.

Must be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces"">namespace</span>:
</div><details><summary>  <span title=""(array) List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller."">ownerReferences</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(string) API version of the referent."">apiVersion</span>:
</div><div style=""margin-left:13px;"">    <span title=""(boolean) If true, AND if the owner has the &#34;foregroundDeletion&#34; finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. Defaults to false. To set this field, a user needs &#34;delete&#34; permission of the owner, otherwise 422 (Unprocessable Entity) will be returned."">blockOwnerDeletion</span>:
</div><div style=""margin-left:13px;"">    <span title=""(boolean) If true, this reference points to the managing controller."">controller</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names"">name</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.

Populated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency"">resourceVersion</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) SelfLink is a URL representing this object. Populated by the system. Read-only."">selfLink</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.

Populated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><details><summary><span title=""(v1beta1.RoleRef) RoleRef can reference a Role in the current namespace or a ClusterRole in the global namespace. If the RoleRef cannot be resolved, the Authorizer must return an error."">roleRef</span>:
</summary><div style=""margin-left:13px;"">  <span title=""(string) APIGroup is the group for the resource being referenced"">apiGroup</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Kind is the type of resource being referenced"">kind</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Name is the name of resource being referenced"">name</span>:
</div></details><details><summary><span title=""(array) Subjects holds references to the objects the role applies to."">subjects</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string) APIGroup holds the API group of the referenced subject. Defaults to &#34;&#34; for ServiceAccount subjects. Defaults to &#34;rbac.authorization.k8s.io&#34; for User and Group subjects."">apiGroup</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Kind of object being referenced. Values defined by this API group are &#34;User&#34;, &#34;Group&#34;, and &#34;ServiceAccount&#34;. If the Authorizer does not recognized the kind value, the Authorizer should report an error."">kind</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Name of the object being referenced."">name</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Namespace of the referenced object.  If the object kind is non-namespace, such as &#34;User&#34; or &#34;Group&#34;, and this value is not empty the Authorizer should report an error."">namespace</span>:
</div></details>
</pre>
++++

== Operations

[[Post-apis-rbac.authorization.k8s.io-v1beta1-namespaces-namespace-rolebindings]]
=== Create a RoleBinding in a namespace
Create a RoleBinding

==== HTTP request
----
POST /apis/rbac.authorization.k8s.io/v1beta1/namespaces/$NAMESPACE/rolebindings HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""RoleBinding"",
  ""apiVersion"": ""rbac.authorization.k8s.io/v1beta1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X POST \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/apis/rbac.authorization.k8s.io/v1beta1/namespaces/$NAMESPACE/rolebindings <<'EOF'
{
  ""kind"": ""RoleBinding"",
  ""apiVersion"": ""rbac.authorization.k8s.io/v1beta1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1beta1.RoleBinding
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1beta1.RoleBinding
|201 Created|v1beta1.RoleBinding
|202 Accepted|v1beta1.RoleBinding
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-apis-rbac.authorization.k8s.io-v1beta1-namespaces-namespace-rolebindings-name]]
=== Get a RoleBinding in a namespace
Read the specified RoleBinding

==== HTTP request
----
GET /apis/rbac.authorization.k8s.io/v1beta1/namespaces/$NAMESPACE/rolebindings/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/rbac.authorization.k8s.io/v1beta1/namespaces/$NAMESPACE/rolebindings/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the RoleBinding
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1beta1.RoleBinding
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-apis-rbac.authorization.k8s.io-v1beta1-rolebindings]]
=== Get all RoleBindings
List or watch objects of kind RoleBinding

==== HTTP request
----
GET /apis/rbac.authorization.k8s.io/v1beta1/rolebindings HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/rbac.authorization.k8s.io/v1beta1/rolebindings
----

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|pretty|If 'true', then the output is pretty printed.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1beta1.RoleBindingList
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-apis-rbac.authorization.k8s.io-v1beta1-namespaces-namespace-rolebindings]]
=== Get all RoleBindings in a namespace
List or watch objects of kind RoleBinding

==== HTTP request
----
GET /apis/rbac.authorization.k8s.io/v1beta1/namespaces/$NAMESPACE/rolebindings HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/rbac.authorization.k8s.io/v1beta1/namespaces/$NAMESPACE/rolebindings
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1beta1.RoleBindingList
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-apis-rbac.authorization.k8s.io-v1beta1-watch-namespaces-namespace-rolebindings-name]]
=== Watch a RoleBinding in a namespace
Watch changes to an object of kind RoleBinding

==== HTTP request
----
GET /apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/$NAMESPACE/rolebindings/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/$NAMESPACE/rolebindings/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the RoleBinding
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|pretty|If 'true', then the output is pretty printed.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.WatchEvent
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-apis-rbac.authorization.k8s.io-v1beta1-watch-rolebindings]]
=== Watch all RoleBindings
Watch individual changes to a list of RoleBinding

==== HTTP request
----
GET /apis/rbac.authorization.k8s.io/v1beta1/watch/rolebindings HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/rbac.authorization.k8s.io/v1beta1/watch/rolebindings
----

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|pretty|If 'true', then the output is pretty printed.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.WatchEvent
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-apis-rbac.authorization.k8s.io-v1beta1-watch-namespaces-namespace-rolebindings]]
=== Watch all RoleBindings in a namespace
Watch individual changes to a list of RoleBinding

==== HTTP request
----
GET /apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/$NAMESPACE/rolebindings HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/rbac.authorization.k8s.io/v1beta1/watch/namespaces/$NAMESPACE/rolebindings
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|pretty|If 'true', then the output is pretty printed.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.WatchEvent
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Put-apis-rbac.authorization.k8s.io-v1beta1-namespaces-namespace-rolebindings-name]]
=== Update a RoleBinding in a namespace
Replace the specified RoleBinding

==== HTTP request
----
PUT /apis/rbac.authorization.k8s.io/v1beta1/namespaces/$NAMESPACE/rolebindings/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""RoleBinding"",
  ""apiVersion"": ""rbac.authorization.k8s.io/v1beta1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X PUT \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/apis/rbac.authorization.k8s.io/v1beta1/namespaces/$NAMESPACE/rolebindings/$NAME <<'EOF'
{
  ""kind"": ""RoleBinding"",
  ""apiVersion"": ""rbac.authorization.k8s.io/v1beta1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1beta1.RoleBinding
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the RoleBinding
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1beta1.RoleBinding
|201 Created|v1beta1.RoleBinding
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Patch-apis-rbac.authorization.k8s.io-v1beta1-namespaces-namespace-rolebindings-name]]
=== Patch a RoleBinding in a namespace
Partially update the specified RoleBinding

==== HTTP request
----
PATCH /apis/rbac.authorization.k8s.io/v1beta1/namespaces/$NAMESPACE/rolebindings/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json-patch+json'

{
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X PATCH \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json-patch+json' \\
    https://$ENDPOINT/apis/rbac.authorization.k8s.io/v1beta1/namespaces/$NAMESPACE/rolebindings/$NAME <<'EOF'
{
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.Patch
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the RoleBinding
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1beta1.RoleBinding
|401 Unauthorized|
|===

==== Consumes

* application/json-patch+json
* application/merge-patch+json
* application/strategic-merge-patch+json

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Delete-apis-rbac.authorization.k8s.io-v1beta1-namespaces-namespace-rolebindings-name]]
=== Delete a RoleBinding in a namespace
Delete a RoleBinding

==== HTTP request
----
DELETE /apis/rbac.authorization.k8s.io/v1beta1/namespaces/$NAMESPACE/rolebindings/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X DELETE \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/apis/rbac.authorization.k8s.io/v1beta1/namespaces/$NAMESPACE/rolebindings/$NAME <<'EOF'
{
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.DeleteOptions
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the RoleBinding
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|gracePeriodSeconds|The duration in seconds before the object should be deleted. Value must be non-negative integer. The value zero indicates delete immediately. If this value is nil, the default grace period for the specified type will be used. Defaults to a per object value if not specified. zero means delete immediately.
|orphanDependents|Deprecated: please use the PropagationPolicy, this field will be deprecated in 1.7. Should the dependent objects be orphaned. If true/false, the ""orphan"" finalizer will be added to/removed from the object's finalizers list. Either this field or PropagationPolicy may be set, but not both.
|propagationPolicy|Whether and how garbage collection will be performed. Either this field or OrphanDependents may be set, but not both. The default policy is decided by the existing finalizer set in the metadata.finalizers and the resource-specific default policy. Acceptable values are: 'Orphan' - orphan the dependents; 'Background' - allow the garbage collector to delete the dependents in the background; 'Foreground' - a cascading policy that deletes all dependents in the foreground.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.Status
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Delete-apis-rbac.authorization.k8s.io-v1beta1-namespaces-namespace-rolebindings]]
=== Delete all RoleBindings in a namespace
Delete collection of RoleBinding

==== HTTP request
----
DELETE /apis/rbac.authorization.k8s.io/v1beta1/namespaces/$NAMESPACE/rolebindings HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
----

==== Curl request
----
$ curl -k \\
    -X DELETE \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    https://$ENDPOINT/apis/rbac.authorization.k8s.io/v1beta1/namespaces/$NAMESPACE/rolebindings
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== Query parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|pretty|If 'true', then the output is pretty printed.
|continue|The continue option should be set when retrieving more results from the server. Since this value is server defined, clients may only use the continue value from a previous query result with identical query parameters (except for the value of continue) and the server may reject a continue value it does not recognize. If the specified continue value is no longer valid whether due to expiration (generally five to fifteen minutes) or a configuration change on the server the server will respond with a 410 ResourceExpired error indicating the client must restart their list without the continue field. This field is not supported when watch is true. Clients may start a watch from the last resourceVersion value returned by the server and not miss any modifications.
|fieldSelector|A selector to restrict the list of returned objects by their fields. Defaults to everything.
|includeUninitialized|If true, partially initialized resources are included in the response.
|labelSelector|A selector to restrict the list of returned objects by their labels. Defaults to everything.
|limit|limit is a maximum number of responses to return for a list call. If more items exist, the server will set the `continue` field on the list metadata to a value that can be used with the same initial query to retrieve the next set of results. Setting a limit may return fewer than the requested amount of items (up to zero items) in the event all requested objects are filtered out and clients should only use the presence of the continue field to determine whether more results are available. Servers may choose not to support the limit argument and will return all of the available results. If limit is specified and the continue field is empty, clients may assume that no more results are available. This field is not supported if watch is true.

The server guarantees that the objects returned when using continue will be identical to issuing a single list call without a limit - that is, no objects created, modified, or deleted after the first request is issued will be included in any subsequent continued requests. This is sometimes referred to as a consistent snapshot, and ensures that a client that is using limit to receive smaller chunks of a very large result can ensure they see all possible objects. If objects are updated during a chunked list the version of the object that was present at the time the first list result was calculated is returned.
|resourceVersion|When specified with a watch call, shows changes that occur after that particular version of a resource. Defaults to changes from the beginning of history. When specified for list: - if unset, then the result is returned from remote storage based on quorum-read flag; - if it's 0, then we simply return what we currently have in cache, no guarantee; - if set to non zero, then the result is at least as fresh as given rv.
|timeoutSeconds|Timeout for the list/watch call. This limits the duration of the call, regardless of any activity or inactivity.
|watch|Watch for changes to the described resources and return them as a stream of add, update, and remove notifications. Specify resourceVersion.
|===

==== Responses
[cols=""1,5"", options=""header""]
|===
|HTTP Code|Schema
|200 OK|v1.Status
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf



",12343,False,2428.1306919115536,median
"#include ""StdAfx.h""
#include ""URLBlaster.h""
#include ""urlBlast.h""
#include ""urlBlastDlg.h""
#include <process.h>
#include <shlwapi.h>
#include <Userenv.h>
#include <Aclapi.h>
#include <Lm.h>
#include <WtsApi32.h>
#include ""TraceRoute.h""
#include ""log.h""

/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
CURLBlaster::CURLBlaster(HWND hWnd, CLog &logRef, CIpfw &ipfwRef, HANDLE &testingMutexRef, CurlBlastDlg &dlgRef)
: userName(_T(""""))
, hLogonToken(NULL)
, hProfile(NULL)
, password(_T(""2dialit""))
, accountBase(_T(""user""))
, hThread(NULL)
, index(0)
, count(0)
, hDlg(hWnd)
, urlManager(NULL)
, timeout(60)
, browserPID(0)
, userSID(NULL)
, log(logRef)
, pipeIn(0)
, pipeOut(0)
, hDynaTrace(NULL)
, useBitBlt(0)
, winpcap(logRef)
, keepDNS(0)
, heartbeatEvent(NULL)
, ipfw(ipfwRef)
, testingMutex(testingMutexRef)
, dlg(dlgRef)
{
	InitializeCriticalSection(&cs);
	hMustExit = CreateEvent(0, TRUE, FALSE, NULL );
	srand(GetTickCount());
}

/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
CURLBlaster::~CURLBlaster(void)
{
	SetEvent(hMustExit);
	
	// wait for the thread to exit (up to 2 hours)
	if( hThread )
	{
		WaitForSingleObject(hThread, 7200);
		CloseHandle(hThread);
	}
	
	if( hLogonToken )
	{
		if( hProfile && hProfile != HKEY_CURRENT_USER )
			UnloadUserProfile( hLogonToken, hProfile );

		CloseHandle( hLogonToken );
	}

  if( heartbeatEvent )
    CloseHandle(heartbeatEvent);
		
	CloseHandle( hMustExit );
	EnterCriticalSection(&cs);
	if( userSID )
	{
		HeapFree(GetProcessHeap(), 0, (LPVOID)userSID);
		userSID = 0;
	}
	LeaveCriticalSection(&cs);
	DeleteCriticalSection(&cs);
}

/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
static unsigned __stdcall ThreadProc( void* arg )
{
	CURLBlaster * blaster = (CURLBlaster *)arg;
	if( blaster )
		blaster->ThreadProc();
		
	return 0;
}

/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
bool CURLBlaster::Start(int userIndex)
{
	bool ret = false;

	TCHAR path[MAX_PATH];
  if( hProfile )
  {
    TCHAR name[1024];
    DWORD len = _countof(name);
    if( GetUserName(name, &len) )
    {
      userName = name;

      if( SHGetSpecialFolderPath(NULL, path, CSIDL_PROFILE, FALSE))
        profile = path;
    }
  }
  else
  {
	  // store off which user this worker belongs to
	  index = userIndex;
	  userName.Format(_T(""%s%d""), (LPCTSTR)accountBase, index);
	  DWORD len = _countof(path);
    profile = CString(_T(""C:\\\\Documents and Settings""));
	  if( GetProfilesDirectory(path, &len) )
		  profile = path;
	  profile += _T(""\\\\"");
	  profile += userName;
  }

  if( !dynaTrace.IsEmpty() && SHGetSpecialFolderPath(NULL, path, CSIDL_PROFILE, FALSE))
  {
    dynaTraceSessions = path;
    dynaTraceSessions += _T(""\\\\.dynaTrace\\\\ajax\\\\browser\\\\iesessions"");

    // create the registry entries to turn it on
    HKEY hKey;
    if( RegCreateKeyEx(HKEY_LOCAL_MACHINE, _T(""System\\\\CurrentControlSet\\\\Control\\\\Session Manager\\\\Environment""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
    {
	    LPCTSTR szTrue = _T(""true"");
	    RegSetValueEx(hKey, _T(""DT_AE_AGENTACTIVE""), 0, REG_SZ, (const LPBYTE)szTrue, (lstrlen(szTrue) + 1) * sizeof(TCHAR));
	    RegSetValueEx(hKey, _T(""DT_IE_AGENT_ACTIVE""), 0, REG_SZ, (const LPBYTE)szTrue, (lstrlen(szTrue) + 1) * sizeof(TCHAR));

      LPCTSTR szSession = _T(""WebPagetest"");
	    RegSetValueEx(hKey, _T(""DT_AE_AGENTNAME""), 0, REG_SZ, (const LPBYTE)szSession, (lstrlen(szSession) + 1) * sizeof(TCHAR));
	    RegSetValueEx(hKey, _T(""DT_IE_SESSION_NAME""), 0, REG_SZ, (const LPBYTE)szSession, (lstrlen(szSession) + 1) * sizeof(TCHAR));

	    RegCloseKey(hKey);
      DWORD result;
      SendMessageTimeoutA(HWND_BROADCAST, WM_SETTINGCHANGE, 0, (LPARAM)""Environment"", SMTO_ABORTIFHUNG, 5000, &result);
    }
  }
	
	info.userName = userName;

  windir = _T(""c:\\\\windows"");
  if( GetWindowsDirectory(path, _countof(path)) )
    windir = path;
	
	// default directories
  if( profile.GetLength() )
  {
	  cookies = profile + _T(""\\\\Cookies"");
	  history = profile + _T(""\\\\Local Settings\\\\History"");
	  tempFiles = profile + _T(""\\\\Local Settings\\\\Temporary Internet Files"");
	  webCache = profile + _T(""\\\\Local Settings\\\\Application Data\\\\Microsoft\\\\Windows\\\\WebCache"");
	  tempDir = profile + _T(""\\\\Local Settings\\\\Temp"");
	  desktopPath = profile + _T(""\\\\Local Settings\\\\Desktop"");
	  silverlight = profile + _T(""\\\\Local Settings\\\\Application Data\\\\Microsoft\\\\Silverlight"");
	  recovery = profile + _T(""\\\\Local Settings\\\\Application Data\\\\Microsoft\\\\Internet Explorer\\\\Recovery\\\\Active"");
	  flash = profile + _T(""\\\\Application Data\\\\Macromedia\\\\Flash Player\\\\#SharedObjects"");
    domStorage = profile + _T(""\\\\Local Settings\\\\Application Data\\\\Microsoft\\\\Internet Explorer\\\\DOMStore"");
  }

  // Get WinPCap ready (install it if necessary)
  winpcap.Initialize();

  // create a heartbeat event that the browser plugin can fire for when scripts are running
	SECURITY_ATTRIBUTES nullDacl;
	ZeroMemory(&nullDacl, sizeof(nullDacl));
	nullDacl.nLength = sizeof(nullDacl);
	nullDacl.bInheritHandle = FALSE;
	SECURITY_DESCRIPTOR SD;
	if( InitializeSecurityDescriptor(&SD, SECURITY_DESCRIPTOR_REVISION) )
		if( SetSecurityDescriptorDacl(&SD, TRUE,(PACL)NULL, FALSE) )
			nullDacl.lpSecurityDescriptor = &SD;
  heartbeatEventName.Format(_T(""Global\\\\URLBlast Heartbeat %d""), userIndex);
  heartbeatEvent = CreateEvent(&nullDacl, FALSE, FALSE, heartbeatEventName);

	// spawn the worker thread
	ResetEvent(hMustExit);
	hThread = (HANDLE)_beginthreadex(0, 0, ::ThreadProc, this, 0, 0);
	if( hThread )
		ret = true;
	
	return ret;
}

/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void CURLBlaster::Stop(void)
{
	SetEvent(hMustExit);
}

/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
void CURLBlaster::ThreadProc(void)
{
	if( DoUserLogon() )
	{
		log.Trace(_T(""Running...""));
		dlg.SetStatus(_T(""Running...""));

		// start off with IPFW in a clean state
    WaitForSingleObject(testingMutex, INFINITE);
		ResetIpfw();
	  Launch(_T(""RunDll32.exe InetCpl.cpl,ClearMyTracksByProcess 6655""));
    ReleaseMutex(testingMutex);

		while( WaitForSingleObject(hMustExit,0) == WAIT_TIMEOUT )
		{
		  dlg.Alive();
		  
			// get the url to test
      WaitForSingleObject(testingMutex, INFINITE);
      dlg.SetStatus(_T(""Checking for work...""));
			if(	GetUrl() )
			{
        if( info.testType.GetLength() )
        {
          // running a custom test
          do
          {
            if( !info.testType.CompareNoCase(_T(""traceroute"")) )
            {
              CTraceRoute tracert(info);
              tracert.Run();
            }

            urlManager->UrlFinished(info);
          }while( !info.done );
        }
        else if( !info.zipFileDir.IsEmpty() )
				{
					EncodeVideo();
					urlManager->UrlFinished(info);
				}
				else
				{
					// loop for as many runs as are needed for the current request
					do
					{
            OutputDebugString(_T(""[UrlBlast] - Clearing Cache""));
            dlg.SetStatus(_T(""[UrlBlast] - Clearing Cache""));
						ClearCache();

						dlg.Alive();
						if( Launch(preLaunch) )
						{
							LaunchBrowser();
              dlg.SetStatus(_T(""Uploading test run...""));
              
							// record the cleared cache view
							if( urlManager->RunRepeatView(info) ) {
							  dlg.Alive();
								LaunchBrowser();
							}

							Launch(postLaunch);
						}

            dlg.SetStatus(_T(""Uploading test run...""));
						urlManager->UrlFinished(info);
					}while( !info.done );
				}
        ReleaseMutex(testingMutex);
        dlg.Alive();
        OutputDebugString(_T(""[UrlBlast] - Test complete""));
        dlg.SetStatus(_T(""[UrlBlast] - Test complete""));
			}
			else
      {
        ReleaseMutex(testingMutex);
        dlg.Alive();
        dlg.SetStatus(_T(""Waiting for next test...""));
				Sleep(500 + (rand() % 500));
      }
		}
	}
}

/*-----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
bool CURLBlaster::DoUserLogon(void)
{
	bool ret = false;
	
  if( hProfile )
    ret = true;
  else
  {
	  log.Trace(_T(""Logging on user:%s, password:%s""), (LPCTSTR)userName, (LPCTSTR)password);
  	
	  // create the account if it doesn't exist
	  USER_INFO_0 * userInfo = NULL;
	  if( !NetUserGetInfo( NULL, userName, 0, (LPBYTE *)&userInfo ) )
		  NetApiBufferFree(userInfo);
	  else
	  {
		  USER_INFO_1 info;
		  memset(&info, 0, sizeof(info));
		  wchar_t name[1000];
		  wchar_t pw[PWLEN];
		  lstrcpyW(name, CT2W(userName));
		  lstrcpyW(pw, CT2W(password));
  		
		  info.usri1_name = name;
		  info.usri1_password = pw;
		  info.usri1_priv = USER_PRIV_USER;
		  info.usri1_comment = L""UrlBlast testing user account"";
		  info.usri1_flags = UF_SCRIPT | UF_DONT_EXPIRE_PASSWD;

		  if( !NetUserAdd(NULL, 1, (LPBYTE)&info, NULL) )
		  {
			  CString msg;
			  msg.Format(_T(""Created user account '%s'""), (LPCTSTR)userName);
			  log.LogEvent(event_Info, 0, msg);
  			
			  // hide the account from the welcome screen
			  HKEY hKey;
			  if( RegCreateKeyEx(HKEY_LOCAL_MACHINE, _T(""SOFTWARE\\\\Microsoft\\\\Windows NT\\\\CurrentVersion\\\\Winlogon\\\\SpecialAccounts\\\\UserList""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
			  {
				  DWORD val = 0;
				  RegSetValueEx(hKey, userName, 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
				  RegCloseKey(hKey);
			  }
		  }
		  else
		  {
			  CString msg;
			  msg.Format(_T(""Failed to create user account '%s'""), (LPCTSTR)userName);
			  log.LogEvent(event_Error, 0, msg);
		  }
	  }
  	
	  // log the user on
	  if( LogonUser(userName, NULL, password, LOGON32_LOGON_INTERACTIVE, LOGON32_PROVIDER_DEFAULT, &hLogonToken) )
	  {
		  TCHAR szUserName[100];
		  lstrcpy( szUserName, (LPCTSTR)userName);

		  // get the SID for the account
		  EnterCriticalSection(&cs);
		  TOKEN_USER * user = NULL;
		  DWORD userLen = 0;
		  DWORD len = 0;
		  GetTokenInformation(hLogonToken, TokenUser, &user, userLen, &len);
		  if( len )
		  {
			  user = (TOKEN_USER *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
			  userLen = len;
			  if( user )
			  {
				  if( GetTokenInformation(hLogonToken, TokenUser, user, userLen, &len) )
				  {
					  if( user->User.Sid && IsValidSid(user->User.Sid) )
					  {
						  len = GetLengthSid(user->User.Sid);
						  userSID = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
						  if( userSID )
							  CopySid(len, userSID, user->User.Sid);
					  }
				  }
				  HeapFree(GetProcessHeap(), 0, (LPVOID)user);

			  }
		  }
		  LeaveCriticalSection(&cs);
  		
		  log.Trace(_T(""Logon ok, loading user profile""));
  		
		  // load their profile
		  PROFILEINFO userProfile;
		  memset( &userProfile, 0, sizeof(userProfile) );
		  userProfile.dwSize = sizeof(userProfile);
		  userProfile.lpUserName = szUserName;

		  if( LoadUserProfile( hLogonToken, &userProfile ) )
		  {
			  hProfile = userProfile.hProfile;
  			
			  log.Trace(_T(""Profile loaded, locating profile directory""));
  			
			  // close the IE settings from the main OS user to the URLBlast user
			  CloneIESettings();

			  // figure out where their directories are
			  TCHAR path[MAX_PATH];
			  DWORD len = _countof(path);
			  if( GetUserProfileDirectory(hLogonToken, path, &len) )
			  {
				  profile = path;
  				
				  HKEY hKey;
				  if( SUCCEEDED(RegOpenKeyEx((HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\Explorer\\\\User Shell Folders""), 0, KEY_READ, &hKey)) )
				  {
					  len = _countof(path);
					  if( SUCCEEDED(RegQueryValueEx(hKey, _T(""Cookies""), 0, 0, (LPBYTE)path, &len)) )
						  cookies = path;

					  len = _countof(path);
					  if( SUCCEEDED(RegQueryValueEx(hKey, _T(""History""), 0, 0, (LPBYTE)path, &len)) )
						  history = path;

					  len = _countof(path);
					  if( SUCCEEDED(RegQueryValueEx(hKey, _T(""Cache""), 0, 0, (LPBYTE)path, &len)) )
						  tempFiles = path;

					  len = _countof(path);
					  if( SUCCEEDED(RegQueryValueEx(hKey, _T(""Desktop""), 0, 0, (LPBYTE)path, &len)) )
						  desktopPath = path;

					  len = _countof(path);
					  if( SUCCEEDED(RegQueryValueEx(hKey, _T(""Local AppData""), 0, 0, (LPBYTE)path, &len)) )
					  {
						  silverlight = path;
              recovery = silverlight + _T(""\\\\Microsoft\\\\Internet Explorer\\\\Recovery\\\\Active"");
						  webCache = silverlight + _T(""\\\\Microsoft\\\\Windows\\\\WebCache"");
						  silverlight += _T(""\\\\Microsoft\\\\Silverlight"");
					  }

					  len = _countof(path);
					  if( SUCCEEDED(RegQueryValueEx(hKey, _T(""Local Settings""), 0, 0, (LPBYTE)path, &len)) )
					  {
              tempDir = path;
              tempDir += _T(""\\\\Temp"");
            }
            else
            {
					    len = _countof(path);
					    if( SUCCEEDED(RegQueryValueEx(hKey, _T(""Local AppData""), 0, 0, (LPBYTE)path, &len)) )
					    {
                tempDir = path;
                tempDir += _T(""\\\\Temp"");
					    }
            }

					  len = _countof(path);
					  if( SUCCEEDED(RegQueryValueEx(hKey, _T(""AppData""), 0, 0, (LPBYTE)path, &len)) )
					  {
						  flash = path;
						  flash += _T(""\\\\Macromedia\\\\Flash Player\\\\#SharedObjects"");
					  }

					  RegCloseKey(hKey);
				  }

				  if( SUCCEEDED(RegOpenKeyEx((HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\Internet Settings\\\\5.0\\\\Cache\\\\Extensible Cache\\\\DOMStore""), 0, KEY_READ, &hKey)) )
				  {
					  len = _countof(path);
					  if( SUCCEEDED(RegQueryValueEx(hKey, _T(""CachePath""), 0, 0, (LPBYTE)path, &len)) )
						  domStorage = path;
            
            RegCloseKey(hKey);
          }

				  cookies.Replace(_T(""%USERPROFILE%""), profile);
				  history.Replace(_T(""%USERPROFILE%""), profile);
				  tempFiles.Replace(_T(""%USERPROFILE%""), profile);
				  webCache.Replace(_T(""%USERPROFILE%""), profile);
				  tempDir.Replace(_T(""%USERPROFILE%""), profile);
				  desktopPath.Replace(_T(""%USERPROFILE%""), profile);
				  silverlight.Replace(_T(""%USERPROFILE%""), profile);
				  recovery.Replace(_T(""%USERPROFILE%""), profile);
				  flash.Replace(_T(""%USERPROFILE%""), profile);
				  domStorage.Replace(_T(""%USERPROFILE%""), profile);
        }
  			
			  ret = true;
		  }
	  }
	  else
	  {
		  log.Trace(_T(""Logon failed: %d""), GetLastError());
		  CString msg;
		  msg.Format(_T(""Logon failed for '%s'""), (LPCTSTR)userName);
		  log.LogEvent(event_Error, 0, msg);
	  }

	  if( ret )
		  log.Trace(_T(""DoUserLogon successful for %s""), (LPCTSTR)userName);
	  else
		  log.Trace(_T(""DoUserLogon failed for %s""), (LPCTSTR)userName);
  }
	
	return ret;
}

int cacheCount;

/*-----------------------------------------------------------------------------
	Launch a process in the given user space that will delete the appropriate folders
-----------------------------------------------------------------------------*/
void CURLBlaster::ClearCache(void)
{
	// delete the cookies, history and temporary internet files for this user
	DeleteDirectory( cookies, false );
	DeleteDirectory( history, false );
  DeleteDirectory( domStorage, false );
	cacheCount = 0;
	DeleteDirectory( tempFiles, false );
	DeleteDirectory( webCache, false );
	DeleteDirectory( tempDir, false );
	CString buff;
	buff.Format(_T(""%d files found in cache\\n""), cacheCount);
	OutputDebugString(buff);
	DeleteDirectory( silverlight, false );
	DeleteDirectory( recovery, false );
	DeleteDirectory( flash, false );
  DeleteFile(desktopPath + _T(""\\\\debug.log""));  // delete the desktop debug log from page speed - argh!
  DeleteDirectory( windir + _T(""\\\\temp""), false );  // delete the global windows temp directory

  // delete the local storage quotas from the registry
  DeleteRegKey((HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Internet Explorer\\\\LowRegistry\\\\DOMStorage""), false);
  DeleteRegKey((HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Internet Explorer\\\\DOMStorage""), false);

  // flush the certificate revocation caches
  if (info.clearCerts) {
    Launch(_T(""certutil.exe -urlcache * delete""));
    Launch(_T(""certutil.exe -setreg chain\\\\ChainCacheResyncFiletime @now""));
  }

  // clear the wininet cache if we are running as the current user
  if (hProfile == HKEY_CURRENT_USER) {
    HANDLE hEntry;
	  DWORD len, entry_size = 0;
    GROUPID id;
    INTERNET_CACHE_ENTRY_INFO * info = NULL;
    HANDLE hGroup = FindFirstUrlCacheGroup(0, CACHEGROUP_SEARCH_ALL, 0, 0, &id, 0);
    if (hGroup) {
	    do {
        len = entry_size;
        hEntry = FindFirstUrlCacheEntryEx(NULL, 0, 0xFFFFFFFF, id, info, &len, NULL, NULL, NULL);
        if (!hEntry && GetLastError() == ERROR_INSUFFICIENT_BUFFER && len) {
          entry_size = len;
          info = (INTERNET_CACHE_ENTRY_INFO *)realloc(info, len);
          if (info) {
            hEntry = FindFirstUrlCacheEntryEx(NULL, 0, 0xFFFFFFFF, id, info, &len, NULL, NULL, NULL);
          }
        }
        if (hEntry && info) {
          bool ok = true;
          do {
            DeleteUrlCacheEntry(info->lpszSourceUrlName);
            len = entry_size;
            if (!FindNextUrlCacheEntryEx(hEntry, info, &len, NULL, NULL, NULL)) {
              if (GetLastError() == ERROR_INSUFFICIENT_BUFFER && len) {
                entry_size = len;
                info = (INTERNET_CACHE_ENTRY_INFO *)realloc(info, len);
                if (info) {
                  if (!FindNextUrlCacheEntryEx(hEntry, info, &len, NULL, NULL, NULL)) {
                    ok = false;
                  }
                }
              } else {
                ok = false;
              }
            }
          } while (ok);
        }
        if (hEntry) {
          FindCloseUrlCache(hEntry);
        }
        DeleteUrlCacheGroup(id, CACHEGROUP_FLAG_FLUSHURL_ONDELETE, 0);
	    } while(FindNextUrlCacheGroup(hGroup, &id,0));
	    FindCloseUrlCache(hGroup);
    }

    len = entry_size;
    hEntry = FindFirstUrlCacheEntryEx(NULL, 0, 0xFFFFFFFF, 0, info, &len, NULL, NULL, NULL);
    if (!hEntry && GetLastError() == ERROR_INSUFFICIENT_BUFFER && len) {
      entry_size = len;
      info = (INTERNET_CACHE_ENTRY_INFO *)realloc(info, len);
      if (info) {
        hEntry = FindFirstUrlCacheEntryEx(NULL, 0, 0xFFFFFFFF, 0, info, &len, NULL, NULL, NULL);
      }
    }
    if (hEntry && info) {
      bool ok = true;
      do {
        DeleteUrlCacheEntry(info->lpszSourceUrlName);
        len = entry_size;
        if (!FindNextUrlCacheEntryEx(hEntry, info, &len, NULL, NULL, NULL)) {
          if (GetLastError() == ERROR_INSUFFICIENT_BUFFER && len) {
            entry_size = len;
            info = (INTERNET_CACHE_ENTRY_INFO *)realloc(info, len);
            if (info) {
              if (!FindNextUrlCacheEntryEx(hEntry, info, &len, NULL, NULL, NULL)) {
                ok = false;
              }
            }
          } else {
            ok = false;
          }
        }
      } while (ok);
    }
    if (hEntry) {
      FindCloseUrlCache(hEntry);
    }

    len = entry_size;
    hEntry = FindFirstUrlCacheEntry(NULL, info, &len);
    if (!hEntry && GetLastError() == ERROR_INSUFFICIENT_BUFFER && len) {
      entry_size = len;
      info = (INTERNET_CACHE_ENTRY_INFO *)realloc(info, len);
      if (info) {
        hEntry = FindFirstUrlCacheEntry(NULL, info, &len);
      }
    }
    if (hEntry && info) {
      bool ok = true;
      do {
        DeleteUrlCacheEntry(info->lpszSourceUrlName);
        len = entry_size;
        if (!FindNextUrlCacheEntry(hEntry, info, &len)) {
          if (GetLastError() == ERROR_INSUFFICIENT_BUFFER && len) {
            entry_size = len;
            info = (INTERNET_CACHE_ENTRY_INFO *)realloc(info, len);
            if (info) {
              if (!FindNextUrlCacheEntry(hEntry, info, &len)) {
                ok = false;
              }
            }
          } else {
            ok = false;
          }
        }
      } while (ok);
    }
    if (hEntry) {
      FindCloseUrlCache(hEntry);
    }
    if (info)
	    free(info);
  }

  // delete any .tmp files in our directory or the root directory of the drive.
  // Not sure where they are coming from but they collect over time.
	TCHAR path[MAX_PATH];
  if (GetModuleFileName(NULL, path, _countof(path))) {
		*PathFindFileName(path) = NULL;
    CString dir = path;
    WIN32_FIND_DATA fd;
    HANDLE find = FindFirstFile(dir + _T(""\\\\*.tmp""), &fd);
    if (find != INVALID_HANDLE_VALUE) {
      do {
        DeleteFile(dir + CString(_T(""\\\\"")) + fd.cFileName);
      } while(FindNextFile(find, &fd));
      FindClose(find);
    }
    find = FindFirstFile(_T(""C:\\\\*.tmp""), &fd);
    if (find != INVALID_HANDLE_VALUE) {
      do {
        DeleteFile(CString(_T(""C:\\\\"")) + fd.cFileName);
      } while(FindNextFile(find, &fd));
      FindClose(find);
    }
  }
  
    // This magic value is the combination of the following bitflags:
  // #define CLEAR_HISTORY         0x0001 // Clears history
  // #define CLEAR_COOKIES         0x0002 // Clears cookies
  // #define CLEAR_CACHE           0x0004 // Clears Temporary Internet Files folder
  // #define CLEAR_CACHE_ALL       0x0008 // Clears offline favorites and download history
  // #define CLEAR_FORM_DATA       0x0010 // Clears saved form data for form auto-fill-in
  // #define CLEAR_PASSWORDS       0x0020 // Clears passwords saved for websites
  // #define CLEAR_PHISHING_FILTER 0x0040 // Clears phishing filter data
  // #define CLEAR_RECOVERY_DATA   0x0080 // Clears webpage recovery data
  // #define CLEAR_PRIVACY_ADVISOR 0x0800 // Clears tracking data
  // #define CLEAR_SHOW_NO_GUI     0x0100 // Do not show a GUI when running the cache clearing
  //
  // Bitflags available but not used in this magic value are as follows:
  // #define CLEAR_USE_NO_THREAD      0x0200 // Do not use multithreading for deletion
  // #define CLEAR_PRIVATE_CACHE      0x0400 // Valid only when browser is in private browsing mode
  // #define CLEAR_DELETE_ALL         0x1000 // Deletes data stored by add-ons
  // #define CLEAR_PRESERVE_FAVORITES 0x2000 // Preserves cached data for ""favorite"" websites

  // Use the command-line version of cache clearing in case WinInet didn't work
  Launch(_T(""RunDll32.exe InetCpl.cpl,ClearMyTracksByProcess 6655""));

	cached = false;
}

/*-----------------------------------------------------------------------------
	Launch the browser and wait for it to exit
-----------------------------------------------------------------------------*/
bool CURLBlaster::LaunchBrowser(void)
{
	bool ret = false;
	info.testResult = -1;

	// flush the DNS cache
  OutputDebugString(_T(""[UrlBlast] - Flushing DNS""));
  if( !keepDNS ) {
    dlg.SetStatus(_T(""Flushing DNS...""));
	  FlushDNS();
	}

  // move the cursor to the top-left corner
  SetCursorPos(0,0);
  ShowCursor(FALSE);
	
	if( !info.url.IsEmpty() )
	{
		STARTUPINFOW si;
		memset(&si, 0, sizeof(si));
		si.cb = sizeof(si);

    OutputDebugString(_T(""[UrlBlast] - Configuring IPFW""));
    dlg.SetStatus(_T(""Configuring IPFW...""));
		if( ConfigureIpfw() )
		{
			if( ConfigureIE() )
			{
				ConfigurePagetest();

        CString browser;
        if( info.browser.GetLength() )
	      {
		      // check to see if the browser is in the same directory - otherwise let the path find it
		      browser = info.browser;
          TCHAR buff[MAX_PATH];
		      if( GetModuleFileName(NULL, buff, _countof(buff)) )
		      {
			      lstrcpy( PathFindFileName(buff), PathFindFileName(browser) );
			      if( GetFileAttributes(buff) != INVALID_FILE_ATTRIBUTES )
				      browser = buff;
		      }
	      }
				
				// build the launch command for IE
				TCHAR exe[MAX_PATH];
				TCHAR commandLine[MAX_PATH + 1024];
				if( !info.url.Left(6).CompareNoCase(_T(""run://"")) )
				{
					// we're launching a custom exe
					CString cmd = info.url.Mid(6);
					CString options;
					int index = cmd.Find(' ');
					if( index > 0 )
					{
						options = cmd.Mid(index + 1);
						cmd = cmd.Left(index);
					}
					cmd.Trim();
					options.Trim();
					
					// get the full path for the exe
					lstrcpy(exe, cmd);

					// build the command line
					lstrcpy( commandLine, _T(""\\"""") );
					lstrcat( commandLine, exe );
					lstrcat( commandLine, _T(""\\"""") );
					if( options.GetLength() )
						lstrcat( commandLine, CString("" "") + options );
				}
        else if( browser.GetLength() )
				{
					// custom browser
					lstrcpy( exe, browser );

					// build the command line
					lstrcpy( commandLine, _T(""\\"""") );
					lstrcat( commandLine, exe );
					lstrcat( commandLine, _T(""\\"""") );
				}
				else
				{
					// we're launching IE
					SHGetFolderPath(NULL, CSIDL_PROGRAM_FILES, 0, SHGFP_TYPE_CURRENT, exe);
					PathAppend(exe, _T(""Internet Explorer\\\\iexplore.exe""));
					
					// give it an about:blank command line for launch
					lstrcpy( commandLine, _T(""\\"""") );
					lstrcat( commandLine, exe );
					lstrcat( commandLine, _T(""\\"" about:blank"") );

					// see if we need to launch dynaTrace
					LaunchDynaTrace();
				}

        // start a packet capture if we need to
        if( !info.tcpdumpFile.IsEmpty() )
          winpcap.StartCapture(info.tcpdumpFile);
				
				PROCESS_INFORMATION pi;
				
				log.Trace(_T(""Launching... user='%s', path='%s', command line='%s'""), (LPCTSTR)userName, (LPCTSTR)exe, (LPCTSTR)commandLine);
				
        OutputDebugString(_T(""[UrlBlast] - Launching Browser""));
        dlg.SetStatus(_T(""Launching Browser...""));

				// launch internet explorer as our user
        if( heartbeatEvent )
          ResetEvent(heartbeatEvent);
				EnterCriticalSection(&cs);
        bool ok = false;
        if( hProfile == HKEY_CURRENT_USER )
        {
				  if( CreateProcess(CT2W(exe), CT2W(commandLine), NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi) )
            ok = true;
        }
        else
        {
				  if( CreateProcessWithLogonW(CT2W((LPCTSTR)userName), NULL, CT2W((LPCTSTR)password), 0, CT2W(exe), CT2W(commandLine), 0, NULL, NULL, &si, &pi) )
            ok = true;
        }

        if( ok )
				{
				  dlg.SetStatus(_T(""Waiting for test to complete...""));
				  
					// keep track of the process ID for the browser we care about
					browserPID = pi.dwProcessId;
					LeaveCriticalSection(&cs);
					
					// boost the browser priority
					SetPriorityClass(pi.hProcess, ABOVE_NORMAL_PRIORITY_CLASS);
					
					log.LogEvent(event_BrowserLaunch, 0, (LPCTSTR)eventName.Left(1000));
					
					// wait for it to exit - give it up to double the timeout value
					// TODO:  have urlManager specify the timeout
				  int multiple = 2;
          if( info.runningScript )
					  multiple = 10;
          if( heartbeatEvent )
          {
            HANDLE handles[2];
            handles[0] = heartbeatEvent;
            handles[1] = pi.hProcess;
            DWORD forceEnd = GetTickCount() + (timeout * multiple * 1000);
            DWORD waitResult;

            // keep looping as long as we keep getting heartbeats
            do 
            {
              waitResult = WaitForMultipleObjects(2, handles, FALSE, timeout * 1000);
              if( waitResult == WAIT_OBJECT_0 + 1 )
                ret = true;
            } while( waitResult == WAIT_OBJECT_0 && GetTickCount() < forceEnd);
          }
          else
          {
					  if( WaitForSingleObject(pi.hProcess, timeout * multiple * 1000) == WAIT_OBJECT_0 )
              ret = true;
          }

          if( ret )
					{
						count++;
						cached = true;
						if( hDlg )
							PostMessage(hDlg, MSG_UPDATE_UI, 0, 0);
					}
					else
					{
						log.LogEvent(event_TerminatedBrowser, 0, (LPCTSTR)eventName.Left(1000));
						TerminateProcess(pi.hProcess, 0);	// kill the browser if it didn't exit on it's own
					}
          OutputDebugString(_T(""[UrlBlast] - Browser Finished""));
					
					EnterCriticalSection(&cs);
					browserPID = 0;
					LeaveCriticalSection(&cs);
					
					CloseHandle(pi.hThread);
					CloseHandle(pi.hProcess);
					
					// get the result
					HKEY hKey;
					if( RegCreateKeyEx((HKEY)hProfile, _T(""SOFTWARE\\\\AOL\\\\ieWatch""), 0, 0, 0, KEY_READ | KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
					{
						info.cpu = 0;
						DWORD len = sizeof(info.cpu);
						RegQueryValueEx(hKey, _T(""cpu""), 0, 0, (LPBYTE)&info.cpu, &len);
								
						RegDeleteValue(hKey, _T(""Result""));
						RegDeleteValue(hKey, _T(""cpu""));
						
						RegCloseKey(hKey);
					}

					// clean up any processes that may have been spawned
					KillProcs();
				}
				else
				{
					LeaveCriticalSection(&cs);
					LPVOID lpvMessageBuffer;
					FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),  MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),  (LPTSTR)&lpvMessageBuffer, 0, NULL);
					LPCTSTR szMsg = (LPCTSTR)lpvMessageBuffer;
					LocalFree(lpvMessageBuffer);

					CString msg;
					msg.Format(_T(""Failed to launch browser '%s' - %s""), (LPCTSTR)szMsg, (LPCTSTR)exe);
					log.LogEvent(event_Error, 0, msg);
				}

        // stop the tcpdump if we started one
        if( !info.tcpdumpFile.IsEmpty() )
          winpcap.StopCapture();

				CloseDynaTrace();
			}

      OutputDebugString(_T(""[UrlBlast] - Resetting IPFW""));
			ResetIpfw();
		}
	}

  // restore the cursor
  ShowCursor(TRUE);
	
	return ret;
}

/*-----------------------------------------------------------------------------
	Get the next url to test
-----------------------------------------------------------------------------*/
bool CURLBlaster::GetUrl(void)
{
	bool ret = false;
	info.Reset();

	// get a new url from the central url manager
	if( urlManager->GetNextUrl(info) )
	{
		info.eventText += customEventText;
		
		ret = true;
	}
	
	return ret;
}

/*-----------------------------------------------------------------------------
	Store the stuff pagetest needs in the registry
-----------------------------------------------------------------------------*/
void CURLBlaster::ConfigurePagetest(void)
{
	if( hProfile )
	{
		// tell it what url to test
		HKEY hKey;
		if( RegCreateKeyEx((HKEY)hProfile, _T(""SOFTWARE\\\\AOL\\\\ieWatch""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		{
			RegSetValueEx(hKey, _T(""url""), 0, REG_SZ, (const LPBYTE)(LPCTSTR)info.url, (info.url.GetLength() + 1) * sizeof(TCHAR));
			DWORD block = 1;
			RegSetValueEx(hKey, _T(""Block All Popups""), 0, REG_DWORD, (const LPBYTE)&block, sizeof(block));
			RegSetValueEx(hKey, _T(""Timeout""), 0, REG_DWORD, (const LPBYTE)&timeout, sizeof(timeout));
			
			// tell ieWatch where to place the browser window
			DWORD val = 0;
			RegSetValueEx(hKey, _T(""Window Left""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			RegSetValueEx(hKey, _T(""Window Top""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			val = pos.right;
			RegSetValueEx(hKey, _T(""Window Width""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			val = pos.bottom;
			RegSetValueEx(hKey, _T(""Window Height""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));

			// delete any old results from the reg key
			RegDeleteValue(hKey, _T(""Result""));
			RegDeleteValue(hKey, _T(""cpu""));

			RegCloseKey(hKey);
		}
		
		// create the event name
		DWORD isCached = 0;
		CString cachedString;
		if( cached )
		{
			cachedString = _T(""Cached-"");
			isCached = 1;
		}
		else
		{
			cachedString = _T(""Cleared Cache-"");
		}

		eventName = cachedString + info.eventText + _T(""^"");
		if( info.runningScript )
		{
			TCHAR script[MAX_PATH];
			lstrcpy(script, info.url.Right(info.url.GetLength() - 9));
			eventName += PathFindFileName(script);
		}
		else
			eventName += info.url;
		
		// give it the event name and log file location
		if( RegCreateKeyEx((HKEY)hProfile, _T(""SOFTWARE\\\\America Online\\\\SOM""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		{
			RegDeleteValue(hKey, _T(""IEWatchLog""));
			if( !info.logFile.IsEmpty() )
				RegSetValueEx(hKey, _T(""IEWatchLog""), 0, REG_SZ, (const LPBYTE)(LPCTSTR)info.logFile, (info.logFile.GetLength() + 1) * sizeof(TCHAR));
			
			RegDeleteValue(hKey, _T(""Links File""));
			if( info.harvestLinks && !info.linksFile.IsEmpty() )
			{
				DeleteFile(info.linksFile);
				RegSetValueEx(hKey, _T(""Links File""), 0, REG_SZ, (const LPBYTE)(LPCTSTR)info.linksFile, (info.linksFile.GetLength() + 1) * sizeof(TCHAR));			
			}
				
			RegDeleteValue(hKey, _T(""404 File""));
			if( !info.s404File.IsEmpty() )
				RegSetValueEx(hKey, _T(""404 File""), 0, REG_SZ, (const LPBYTE)(LPCTSTR)info.s404File, (info.s404File.GetLength() + 1) * sizeof(TCHAR));			

			RegDeleteValue(hKey, _T(""HTML File""));
			if( !info.htmlFile.IsEmpty() )
				RegSetValueEx(hKey, _T(""HTML File""), 0, REG_SZ, (const LPBYTE)(LPCTSTR)info.htmlFile, (info.htmlFile.GetLength() + 1) * sizeof(TCHAR));			

			RegDeleteValue(hKey, _T(""Cookies File""));
			if( !info.cookiesFile.IsEmpty() )
				RegSetValueEx(hKey, _T(""Cookies File""), 0, REG_SZ, (const LPBYTE)(LPCTSTR)info.cookiesFile, (info.cookiesFile.GetLength() + 1) * sizeof(TCHAR));			

			RegSetValueEx(hKey, _T(""EventName""), 0, REG_SZ, (const LPBYTE)(LPCTSTR)eventName, (eventName.GetLength() + 1) * sizeof(TCHAR));
			RegSetValueEx(hKey, _T(""Cached""), 0, REG_DWORD, (const LPBYTE)&isCached, sizeof(isCached));
			RegSetValueEx(hKey, _T(""URL""), 0, REG_SZ, (const LPBYTE)(LPCTSTR)info.url, (info.url.GetLength() + 1) * sizeof(TCHAR));
			RegSetValueEx(hKey, _T(""DOM Element ID""), 0, REG_SZ, (const LPBYTE)(LPCTSTR)info.domElement, (info.domElement.GetLength() + 1) * sizeof(TCHAR));
			RegSetValueEx(hKey, _T(""Check Optimizations""), 0, REG_DWORD, (const LPBYTE)&info.checkOpt, sizeof(info.checkOpt));
      RegSetValueEx(hKey, _T(""No Headers""), 0, REG_DWORD, (const LPBYTE)&info.noHeaders, sizeof(info.noHeaders));
      RegSetValueEx(hKey, _T(""No Images""), 0, REG_DWORD, (const LPBYTE)&info.noImages, sizeof(info.noImages));
      RegSetValueEx(hKey, _T(""Run""), 0, REG_DWORD, (const LPBYTE)&info.currentRun, sizeof(info.currentRun));
			
			RegSetValueEx(hKey, _T(""Include Object Data""), 0, REG_DWORD, (const LPBYTE)&info.includeObjectData, sizeof(info.includeObjectData));


			RegSetValueEx(hKey, _T(""ignoreSSL""), 0, REG_DWORD, (const LPBYTE)&info.ignoreSSL, sizeof(info.ignoreSSL));
			RegSetValueEx(hKey, _T(""clearShortTermCacheSecs""), 0, REG_DWORD, (const LPBYTE)&info.clearShortTermCacheSecs, sizeof(info.clearShortTermCacheSecs));
			
			CString descriptor = _T(""Launch"");
			RegSetValueEx(hKey, _T(""Descriptor""), 0, REG_SZ, (const LPBYTE)(LPCTSTR)descriptor, (descriptor.GetLength() + 1) * sizeof(TCHAR));

			DWORD abm = 1;
			if( info.urlType == 1 )
				abm = 0;
			RegSetValueEx(hKey, _T(""ABM""), 0, REG_DWORD, (const LPBYTE)&abm, sizeof(abm));

			DWORD val = 0;
			if( info.saveEverything )
				val = 1;
			RegSetValueEx(hKey, _T(""Save Everything""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));

			val = 0;
			if( info.captureVideo )
				val = 1;
			RegSetValueEx(hKey, _T(""Capture Video""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));

		  RegSetValueEx(hKey, _T(""pngScreenShot""), 0, REG_DWORD, (const LPBYTE)&info.pngScreenShot, sizeof(info.pngScreenShot));
		  RegSetValueEx(hKey, _T(""imageQuality""), 0, REG_DWORD, (const LPBYTE)&info.imageQuality, sizeof(info.imageQuality));
      RegSetValueEx(hKey, _T(""bodies""), 0, REG_DWORD, (const LPBYTE)&info.bodies, sizeof(info.bodies));
      RegSetValueEx(hKey, _T(""htmlbody""), 0, REG_DWORD, (const LPBYTE)&info.htmlbody, sizeof(info.htmlbody));
      RegSetValueEx(hKey, _T(""keepua""), 0, REG_DWORD, (const LPBYTE)&info.keepua, sizeof(info.keepua));
      RegSetValueEx(hKey, _T(""minimumDuration""), 0, REG_DWORD, (const LPBYTE)&info.minimumDuration, sizeof(info.minimumDuration));
      RegSetValueEx(hKey, _T(""customRules""), 0, REG_SZ, (const LPBYTE)(LPCTSTR)info.customRules, (info.customRules.GetLength() + 1) * sizeof(TCHAR));

		  // Add the blockads bit.
		  RegSetValueEx(hKey, _T(""blockads""), 0, REG_DWORD, (const LPBYTE)&info.blockads, sizeof(info.blockads));


			RegDeleteValue(hKey, _T(""Block""));
			if( !info.block.IsEmpty() )
				RegSetValueEx(hKey, _T(""Block""), 0, REG_SZ, (const LPBYTE)(LPCTSTR)info.block, (info.block.GetLength() + 1) * sizeof(TCHAR));
				
			RegDeleteValue(hKey, _T(""Basic Auth""));
			if( !info.basicAuth.IsEmpty() )
				RegSetValueEx(hKey, _T(""Basic Auth""), 0, REG_SZ, (const LPBYTE)(LPCTSTR)info.basicAuth, (info.basicAuth.GetLength() + 1) * sizeof(TCHAR));

			RegDeleteValue(hKey, _T(""Host""));
			if( !info.host.IsEmpty() )
				RegSetValueEx(hKey, _T(""Host""), 0, REG_SZ, (const LPBYTE)(LPCTSTR)info.host, (info.host.GetLength() + 1) * sizeof(TCHAR));

      RegSetValueEx(hKey, _T(""Heartbeat Event""), 0, REG_SZ, (const LPBYTE)(LPCTSTR)heartbeatEventName, (heartbeatEventName.GetLength() + 1) * sizeof(TCHAR));

			RegCloseKey(hKey);
		}
		
	}
}

/*-----------------------------------------------------------------------------
	Setup the IE settings so we don't get a bunch of dialogs
-----------------------------------------------------------------------------*/
bool CURLBlaster::ConfigureIE(void)
{
	bool ret = false;

	if( hProfile )
	{
		ret = true;

		// Set some basic IE options
		HKEY hKey;
		if( RegCreateKeyEx((HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Internet Explorer\\\\Main""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		{
			LPCTSTR szVal = _T(""yes"");
			RegSetValueEx(hKey, _T(""DisableScriptDebuggerIE""), 0, REG_SZ, (const LPBYTE)szVal, (lstrlen(szVal) + 1) * sizeof(TCHAR));

			szVal = _T(""no"");
			RegSetValueEx(hKey, _T(""FormSuggest PW Ask""), 0, REG_SZ, (const LPBYTE)szVal, (lstrlen(szVal) + 1) * sizeof(TCHAR));
			RegSetValueEx(hKey, _T(""Friendly http errors""), 0, REG_SZ, (const LPBYTE)szVal, (lstrlen(szVal) + 1) * sizeof(TCHAR));
			RegSetValueEx(hKey, _T(""Use FormSuggest""), 0, REG_SZ, (const LPBYTE)szVal, (lstrlen(szVal) + 1) * sizeof(TCHAR));

			DWORD val = 1;
			RegSetValueEx(hKey, _T(""NoUpdateCheck""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			RegSetValueEx(hKey, _T(""NoJITSetup""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			RegSetValueEx(hKey, _T(""NoWebJITSetup""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			RegSetValueEx(hKey, _T(""UseSWRender""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));

			RegCloseKey(hKey);
		}
		
	  if( RegCreateKeyEx(HKEY_LOCAL_MACHINE, _T(""Software\\\\Microsoft\\\\Internet Explorer\\\\Main\\\\FeatureControl\\\\FEATURE_DOWNLOAD_INITIATOR_HTTP_HEADER""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
	  {
		  DWORD val = 1;
		  RegSetValueEx(hKey, _T(""*""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
		  RegCloseKey(hKey);
	  }

	  if( RegCreateKeyEx(HKEY_LOCAL_MACHINE, _T(""Software\\\\Wow6432Node\\\\Microsoft\\\\Internet Explorer\\\\Main\\\\FeatureControl\\\\FEATURE_DOWNLOAD_INITIATOR_HTTP_HEADER""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
	  {
		  DWORD val = 1;
		  RegSetValueEx(hKey, _T(""*""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
		  RegCloseKey(hKey);
	  }

		if( RegCreateKeyEx((HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Internet Explorer\\\\InformationBar""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		{
			DWORD val = 0;
			RegSetValueEx(hKey, _T(""FirstTime""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));

			RegCloseKey(hKey);
		}

		if( RegCreateKeyEx((HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Internet Explorer\\\\IntelliForms""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		{
			DWORD val = 0;
			RegSetValueEx(hKey, _T(""AskUser""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));

			RegCloseKey(hKey);
		}

		if( RegCreateKeyEx((HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Internet Explorer\\\\Security""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		{
			LPCTSTR szVal = _T(""Query"");
			RegSetValueEx(hKey, _T(""Safety Warning Level""), 0, REG_SZ, (const LPBYTE)szVal, (lstrlen(szVal) + 1) * sizeof(TCHAR));

			szVal = _T(""Medium"");
			RegSetValueEx(hKey, _T(""Sending_Security""), 0, REG_SZ, (const LPBYTE)szVal, (lstrlen(szVal) + 1) * sizeof(TCHAR));

			szVal = _T(""Low"");
			RegSetValueEx(hKey, _T(""Viewing_Security""), 0, REG_SZ, (const LPBYTE)szVal, (lstrlen(szVal) + 1) * sizeof(TCHAR));

			RegCloseKey(hKey);
		}

		if( RegCreateKeyEx((HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\Internet Settings""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		{
			DWORD val = 1;
			RegSetValueEx(hKey, _T(""AllowCookies""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			RegSetValueEx(hKey, _T(""EnableHttp1_1""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			RegSetValueEx(hKey, _T(""ProxyHttp1.1""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			RegSetValueEx(hKey, _T(""EnableNegotiate""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));

			val = 0;
			RegSetValueEx(hKey, _T(""WarnAlwaysOnPost""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			RegSetValueEx(hKey, _T(""WarnonBadCertRecving""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			RegSetValueEx(hKey, _T(""WarnOnPost""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			RegSetValueEx(hKey, _T(""WarnOnPostRedirect""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			RegSetValueEx(hKey, _T(""WarnOnZoneCrossing""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			//RegSetValueEx(hKey, _T(""ProxyEnable""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			
			RegCloseKey(hKey);
		}

		if( RegCreateKeyEx((HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\Internet Settings\\\\5.0\\\\Cache\\\\Content""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		{
			DWORD val = 131072;
			RegSetValueEx(hKey, _T(""CacheLimit""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			RegCloseKey(hKey);
		}

		if( RegCreateKeyEx((HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\Internet Settings\\\\Cache\\\\Content""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		{
			DWORD val = 131072;
			RegSetValueEx(hKey, _T(""CacheLimit""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			RegCloseKey(hKey);
		}

		// reset the toolbar layout (to make sure the sidebar isn't open)		
		if( RegCreateKeyEx((HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Internet Explorer\\\\Toolbar\\\\WebBrowser""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		{
			RegDeleteValue(hKey, _T(""ITBarLayout""));
			RegCloseKey(hKey);
		}
		
		// Tweak the security zone to eliminate some warnings
		if( RegCreateKeyEx((HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\Internet Settings\\\\Zones\\\\3""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		{
			DWORD val = 0;
			
			// don't warn about posting data
			RegSetValueEx(hKey, _T(""1601""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));

			// don't warn about mixed content
			RegSetValueEx(hKey, _T(""1609""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));

			RegCloseKey(hKey);
		}

	  // see what version of IE is installed
	  DWORD ver = 0;
	  CRegKey key;
	  if( SUCCEEDED(key.Open(HKEY_LOCAL_MACHINE, _T(""SOFTWARE\\\\Microsoft\\\\Internet Explorer""), KEY_READ)) )
	  {
		  TCHAR buff[1024];
		  ULONG len;
		  len = _countof(buff);
		  if( SUCCEEDED(key.QueryStringValue(_T(""Version""), buff, &len)) )
			  ver = _ttol(buff);
	  }

	  // Disable IE7  emulation for IE8
	  if( ver >= 8 )
	  {
		  if( RegCreateKeyEx(HKEY_LOCAL_MACHINE, _T(""Software\\\\Microsoft\\\\Internet Explorer\\\\Main\\\\FeatureControl\\\\FEATURE_BROWSER_EMULATION""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		  {
			  DWORD val = 8000;
        if( ver > 8 )
          val = 9000;
			  RegSetValueEx(hKey, _T(""pagetest.exe""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			  RegCloseKey(hKey);
		  }
		  if( RegCreateKeyEx((HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Internet Explorer\\\\Main\\\\FeatureControl\\\\FEATURE_BROWSER_EMULATION""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		  {
        RegDeleteValue(hKey, _T(""pagetest.exe""));
			  RegCloseKey(hKey);
		  }
  		
		  // set up IE8/9 connection settings
		  if( RegCreateKeyEx(HKEY_LOCAL_MACHINE, _T(""SOFTWARE\\\\Microsoft\\\\Internet Explorer\\\\MAIN\\\\FeatureControl\\\\FEATURE_MAXCONNECTIONSPERSERVER""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		  {
			  DWORD val = 6;
			  RegSetValueEx(hKey, _T(""pagetest.exe""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			  RegCloseKey(hKey);
		  }
		  if( RegCreateKeyEx((HKEY)hProfile, _T(""SOFTWARE\\\\Microsoft\\\\Internet Explorer\\\\MAIN\\\\FeatureControl\\\\FEATURE_MAXCONNECTIONSPERSERVER""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		  {
        RegDeleteValue(hKey, _T(""pagetest.exe""));
			  RegCloseKey(hKey);
		  }
		  if( RegCreateKeyEx(HKEY_LOCAL_MACHINE, _T(""SOFTWARE\\\\Microsoft\\\\Internet Explorer\\\\MAIN\\\\FeatureControl\\\\FEATURE_MAXCONNECTIONSPER1_0SERVER""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		  {
			  DWORD val = 6;
			  RegSetValueEx(hKey, _T(""pagetest.exe""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			  RegCloseKey(hKey);
		  }
		  if( RegCreateKeyEx((HKEY)hProfile, _T(""SOFTWARE\\\\Microsoft\\\\Internet Explorer\\\\MAIN\\\\FeatureControl\\\\FEATURE_MAXCONNECTIONSPER1_0SERVER""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		  {
        RegDeleteValue(hKey, _T(""pagetest.exe""));
			  RegCloseKey(hKey);
		  }
	  }

    // configure the compatibility view settings
	  if( RegCreateKeyEx((HKEY)hProfile, _T(""SOFTWARE\\\\Microsoft\\\\Internet Explorer\\\\BrowserEmulation""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
	  {
		  DWORD val = 1;
      if (info.standards)
        val = 0;
		  RegSetValueEx(hKey, _T(""MSCompatibilityMode""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
		  RegCloseKey(hKey);
	  }

    // configure javascript
	  if( RegCreateKeyEx((HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\Internet Settings\\\\Zones\\\\3""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
	  {
		  DWORD val = 0;
      if (info.noscript)
        val = 3;
		  RegSetValueEx(hKey, _T(""1400""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
		  RegCloseKey(hKey);
	  }


    // configure Chrome Frame to be the default renderer (if it is installed)
		if( RegCreateKeyEx((HKEY)hProfile, _T(""Software\\\\Google\\\\ChromeFrame""), 0, 0, 0, KEY_WRITE, 0, &hKey, 0) == ERROR_SUCCESS )
		{
			DWORD val = 1;
			RegSetValueEx(hKey, _T(""IsDefaultRenderer""), 0, REG_DWORD, (const LPBYTE)&val, sizeof(val));
			RegCloseKey(hKey);
		}
  }

	return ret;
}

/*-----------------------------------------------------------------------------
	Recusrively copy the IE settings
-----------------------------------------------------------------------------*/
void CURLBlaster::CloneIESettings(void)
{
	CloneRegKey( HKEY_CURRENT_USER, (HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Internet Explorer"") );
	CloneRegKey( HKEY_CURRENT_USER, (HKEY)hProfile, _T(""Software\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\Internet Settings"") );
}

/*-----------------------------------------------------------------------------
	Recusrively copy a registry key
-----------------------------------------------------------------------------*/
void CURLBlaster::CloneRegKey(HKEY hSrc, HKEY hDest, LPCTSTR subKey)
{
	HKEY src;
	if( RegOpenKeyEx(hSrc, subKey, 0, KEY_READ, &src) == ERROR_SUCCESS )
	{
		HKEY dest;
		if( RegCreateKeyEx(hDest, subKey, 0, 0, 0, KEY_WRITE, 0, &dest, 0) == ERROR_SUCCESS )
		{
			// copy all of the values over
			DWORD nameSize = 16384;
			DWORD valSize = 32767;
			
			TCHAR * name = new TCHAR[nameSize];
			LPBYTE data = new BYTE[valSize];
			DWORD nameLen = nameSize;
			DWORD dataLen = valSize;

			DWORD type;
			DWORD index = 0;
			while( RegEnumValue(src, index, name, &nameLen, 0, &type, data, &dataLen) == ERROR_SUCCESS )
			{
				RegSetValueEx(dest, name, 0, type, data, dataLen);
				
				index++;
				nameLen = nameSize;
				dataLen = valSize;
			}
			
			// copy all of the sub-keys over
			index = 0;
			nameLen = nameSize;
			while( RegEnumKeyEx(src, index, name, &nameLen, 0, 0, 0, 0) == ERROR_SUCCESS )
			{
        // don't copy the search providers key, this can triggere IE messages
        if( _tcsicmp(name, _T(""SearchScopes"")) )
				  CloneRegKey(src, dest, name);
				
				index++;
				nameLen = nameSize;
			}

			delete [] name;
			delete [] data;
			
			RegCloseKey(dest);
		}
		
		RegCloseKey(src);
	}
}

/*-----------------------------------------------------------------------------
	Encode a video job
-----------------------------------------------------------------------------*/
void CURLBlaster::EncodeVideo(void)
{
	TCHAR path[MAX_PATH];
	if( GetModuleFileName(NULL, path, _countof(path)) )
	{
		lstrcpy(PathFindFileName(path), _T(""x264.exe""));
		CString exe(path);
		CString cmd = CString(_T(""\\"""")) + exe + _T(""\\"" --crf 24 --profile baseline --preset slow --threads 1 --keyint 10 --min-keyint 1 -o video.mp4 video.avs"");

		PROCESS_INFORMATION pi;
		STARTUPINFO si;
		memset( &si, 0, sizeof(si) );
		si.cb = sizeof(si);
		si.dwFlags = STARTF_USESHOWWINDOW;
		si.wShowWindow = SW_HIDE;
		log.Trace(_T(""Executing '%s' in '%s'""), (LPCTSTR)cmd, (LPCTSTR)info.zipFileDir);
		if( CreateProcess((LPCTSTR)exe, (LPTSTR)(LPCTSTR)cmd, 0, 0, FALSE, IDLE_PRIORITY_CLASS , 0, (LPCTSTR)info.zipFileDir, &si, &pi) )
		{
			if (WaitForSingleObject(pi.hProcess, 5 * 60 * 1000) == WAIT_ABANDONED)
			  TerminateProcess(pi.hProcess, 0);
			CloseHandle(pi.hThread);
			CloseHandle(pi.hProcess);
			log.Trace(_T(""Successfully ran '%s'""), (LPCTSTR)cmd);
		}
		else
			log.Trace(_T(""Execution failed '%s'""), (LPCTSTR)cmd);
	}
}

/*-----------------------------------------------------------------------------
	Launch the given exe and ensure that we get a clean return code
-----------------------------------------------------------------------------*/
bool CURLBlaster::Launch(CString cmd, HANDLE * phProc)
{
	bool ret = false;

	if( cmd.GetLength() )
	{
		PROCESS_INFORMATION pi;
		STARTUPINFO si;
		memset( &si, 0, sizeof(si) );
		si.cb = sizeof(si);
		si.dwFlags = STARTF_USESHOWWINDOW;
		si.wShowWindow = SW_HIDE;
		log.Trace(_T(""Executing '%s'""), (LPCTSTR)cmd);
		if( CreateProcess(NULL, (LPTSTR)(LPCTSTR)cmd, 0, 0, FALSE, NORMAL_PRIORITY_CLASS , 0, NULL, &si, &pi) )
		{
			if( phProc )
			{
				*phProc = pi.hProcess;
				CloseHandle(pi.hThread);
			}
			else
			{
				WaitForSingleObject(pi.hProcess, 60 * 60 * 1000);

				DWORD code;
				if( GetExitCodeProcess(pi.hProcess, &code) && code == 0 )
					ret = true;

				CloseHandle(pi.hThread);
				CloseHandle(pi.hProcess);
				log.Trace(_T(""Successfully ran '%s'""), (LPCTSTR)cmd);
			}
		}
		else
			log.Trace(_T(""Execution failed '%s'""), (LPCTSTR)cmd);
	}
	else
		ret = true;

	return ret;
}

/*-----------------------------------------------------------------------------
	Set up bandwidth throttling
-----------------------------------------------------------------------------*/
bool CURLBlaster::ConfigureIpfw(void)
{
	bool ret = false;

	if( pipeIn && pipeOut && info.ipfw && info.bwIn && info.bwOut )
	{
		// split the latency across directions
		DWORD latency = info.latency / 2;

		CString buff;
		buff.Format(_T(""[urlblast] - Throttling: %d Kbps in, %d Kbps out, %d ms latency, %0.2f plr""), info.bwIn, info.bwOut, info.latency, info.plr );
		OutputDebugString(buff);

		// create the inbound pipe
		if( ipfw.SetPipe(pipeIn, info.bwIn, latency, info.plr / 100.0) )
		{
			// make up for odd values
			if( info.latency % 2 )
				latency++;

			// create the outbound pipe
			if( ipfw.SetPipe(pipeOut, info.bwOut, latency, info.plr / 100.0) )
				ret = true;
			else
				ipfw.SetPipe(pipeIn, 0, 0, 0);
		}
	}
	else
		ret = true;

	return ret;
}

/*-----------------------------------------------------------------------------
	Remove the bandwidth throttling
-----------------------------------------------------------------------------*/
void CURLBlaster::ResetIpfw(void)
{
	if( pipeIn )
		ipfw.SetPipe(pipeIn, 0, 0, 0);
	if( pipeOut )
		ipfw.SetPipe(pipeOut, 0, 0, 0);
}

/*-----------------------------------------------------------------------------
	Terminate any procs that are running under our test user account
	in case something got spawned while testing
-----------------------------------------------------------------------------*/
void CURLBlaster::KillProcs()
{
	#ifndef _DEBUG
	
	WTS_PROCESS_INFO * proc = NULL;
	DWORD count = 0;
	if( hProfile != HKEY_CURRENT_USER && WTSEnumerateProcesses(WTS_CURRENT_SERVER_HANDLE, 0, 1, &proc, &count) )
	{
		for( DWORD i = 0; i < count; i++ )
		{
			// see if the SID matches
			if( userSID && proc[i].pUserSid && IsValidSid(userSID) && IsValidSid(proc[i].pUserSid) )
			{
				if( EqualSid(proc[i].pUserSid, userSID ) )
				{
					HANDLE hProc = OpenProcess(PROCESS_TERMINATE, FALSE, proc[i].ProcessId);
					if( hProc )
					{
						TerminateProcess(hProc, 0);
						CloseHandle(hProc);
					}
				}
			}
		}
		
		WTSFreeMemory(proc);
	}
	#endif
}

typedef int (CALLBACK* DNSFLUSHPROC)();

/*-----------------------------------------------------------------------------
	Flush the OS DNS cache
-----------------------------------------------------------------------------*/
void CURLBlaster::FlushDNS()
{
	bool flushed = false;
	HINSTANCE		hDnsDll;

	log.Trace(_T(""Flushing DNS cache""));

	hDnsDll = LoadLibrary(_T(""dnsapi.dll""));
	if( hDnsDll )
	{
		DNSFLUSHPROC pDnsFlushProc = (DNSFLUSHPROC)GetProcAddress(hDnsDll, ""DnsFlushResolverCache"");
		if( pDnsFlushProc )
		{
			int ret = pDnsFlushProc();
			if( ret == ERROR_SUCCESS)
			{
				flushed = true;
				log.Trace(_T(""Successfully flushed the DNS resolved cache""));
			}
			else
				log.Trace(_T(""DnsFlushResolverCache returned %d""), ret);
		}
		else
			log.Trace(_T(""Failed to load dnsapi.dll""));

		FreeLibrary(hDnsDll);
	}
	else
		log.Trace(_T(""Failed to load dnsapi.dll""));

	if( !flushed )
		Launch(_T(""ipconfig.exe /flushdns""));
}

/*-----------------------------------------------------------------------------
	Launch Dynatrace (if necessary)
-----------------------------------------------------------------------------*/
void CURLBlaster::LaunchDynaTrace()
{
	if( !dynaTrace.IsEmpty() )
	{
    // delete the existing dynatrace sessions
    if( dynaTraceSessions.GetLength() )
      DeleteDirectory(dynaTraceSessions, false);

		Launch(dynaTrace, &hDynaTrace);
		WaitForInputIdle(hDynaTrace, 30000);
	}
}

/*-----------------------------------------------------------------------------
	Close Dynatrace (if necessary)
-----------------------------------------------------------------------------*/
void CURLBlaster::CloseDynaTrace()
{
	if( hDynaTrace )
	{
		HWND hWnd = FindWindow(NULL, _T(""dynaTrace AJAX Edition""));
		PostMessage(hWnd, WM_CLOSE, 0, 0);
		if( WaitForSingleObject(hDynaTrace, 60000) == WAIT_TIMEOUT )
			TerminateProcess(hDynaTrace,0);
		CloseHandle(hDynaTrace);

		// zip up the profile data to our test results folder
    if( dynaTraceSessions.GetLength() )
			ZipDir(dynaTraceSessions, info.logFile + _T(""_dynaTrace.dtas""), _T(""""), NULL);
	}
}

/*-----------------------------------------------------------------------------
	Archive (and delete) the given directory
-----------------------------------------------------------------------------*/
int CURLBlaster::ZipDir(CString dir, CString dest, CString depth, zipFile file)
{
	bool top = false;
  int count = 0;

	// start by creating an empty zip file
	if( !file )
	{
		file = zipOpen(CT2A(dest), APPEND_STATUS_CREATE);
		top = true;
	}

	if( file )
	{
		WIN32_FIND_DATA fd;
		HANDLE hFind = FindFirstFile( dir + _T(""\\\\*.*""), &fd );
		if( hFind != INVALID_HANDLE_VALUE )
		{
			do
			{
				// skip over . and ..
				if( lstrcmp(fd.cFileName, _T(""."")) && lstrcmp(fd.cFileName, _T("".."")) )
				{
					if( fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
					{
						CString d = fd.cFileName;
						if( depth.GetLength() )
							d = depth + CString(_T(""\\\\"")) + fd.cFileName;

						count += ZipDir( dir + CString(_T(""\\\\"")) + fd.cFileName, dest, d, file);
						RemoveDirectory(dir + CString(_T(""\\\\"")) + fd.cFileName);
					}
					else
					{
						CString archiveFile;
						if( depth.GetLength() )
							archiveFile = depth + CString(_T(""/""));
						archiveFile += fd.cFileName;

						CString filePath = dir + CString(_T(""\\\\"")) + fd.cFileName;

						// add the file to the zip archive
						HANDLE hFile = CreateFile( filePath, GENERIC_READ, FILE_SHARE_READ, 0, OPEN_EXISTING, 0, 0);
						if( hFile != INVALID_HANDLE_VALUE )
						{
							DWORD size = GetFileSize(hFile, 0);
							if( size )
							{
								BYTE * mem = (BYTE *)malloc(size);
								if( mem )
								{
									DWORD bytes;
									if( ReadFile(hFile, mem, size, &bytes, 0) && size == bytes )
									{
										// add the file to the archive
										if( !zipOpenNewFileInZip( file, CT2A(archiveFile), 0, 0, 0, 0, 0, 0, Z_DEFLATED, Z_BEST_COMPRESSION ) )
										{
											// write the file to the archive
											zipWriteInFileInZip( file, mem, size );
											zipCloseFileInZip( file );
                      count++;
										}
									}
									
									free(mem);
								}
							}
							
							CloseHandle( hFile );
						}

						DeleteFile(filePath);
					}
				}
			}while( FindNextFile(hFind, &fd) );
			FindClose(hFind);
		}
	}

	// if we're done with the root, delete everything
	if( top && file )
  {
		zipClose(file, 0);
    if( !count )
      DeleteFile(dest);
  }

  return count;
}
",16368,True,3122.1502677936674,median
"#include ""umlReflectionExec/ReadLinkObjectEndQualifierActionObject.hpp""

//General Includes
#include ""abstractDataTypes/SubsetUnion.hpp""
#include ""uml/ReadLinkObjectEndQualifierAction.hpp""
#include ""umlReflection/UMLPackage.hpp""
#include ""fUML/Semantics/Loci/Locus.hpp""
#include ""uml/Class.hpp""
//Includes From Composite Structures
/*Not done for metamodel object classes*/
//Execution Engine Includes
#include ""abstractDataTypes/Any.hpp""
#include ""PSCS/Semantics/StructuredClassifiers/StructuredClassifiersFactory.hpp""
#include ""PSCS/Semantics/StructuredClassifiers/CS_Reference.hpp""
#include ""fUML/Semantics/SimpleClassifiers/SimpleClassifiersFactory.hpp""
#include ""fUML/Semantics/Values/Value.hpp""
#include ""fUML/Semantics/SimpleClassifiers/FeatureValue.hpp""
#include ""PSCS/Semantics/StructuredClassifiers/CS_Link.hpp""
#include ""PSCS/Semantics/StructuredClassifiers/CS_InteractionPoint.hpp""
#include ""fUML/Semantics/CommonBehavior/Execution.hpp""
#include ""fUML/Semantics/CommonBehavior/CommonBehaviorFactory.hpp""
#include ""fUML/Semantics/Loci/ExecutionFactory.hpp""
#include ""fUML/Semantics/Loci/ChoiceStrategy.hpp""
//UML Includes
#include ""uml/umlPackage.hpp""
#include ""uml/Association.hpp""
#include ""uml/Connector.hpp""
#include ""uml/ConnectorEnd.hpp""
#include ""uml/Operation.hpp""
#include ""uml/Property.hpp""
#include ""uml/Port.hpp""
//Property Includes
#include ""uml/Classifier.hpp""
#include ""umlReflectionExec/ClassifierObject.hpp""
#include ""uml/InputPin.hpp""
#include ""umlReflectionExec/InputPinObject.hpp""
#include ""fUML/Semantics/SimpleClassifiers/BooleanValue.hpp""
#include ""uml/Constraint.hpp""
#include ""umlReflectionExec/ConstraintObject.hpp""
#include ""uml/Constraint.hpp""
#include ""umlReflectionExec/ConstraintObject.hpp""
#include ""uml/OutputPin.hpp""
#include ""umlReflectionExec/OutputPinObject.hpp""
#include ""uml/Activity.hpp""
#include ""umlReflectionExec/ActivityObject.hpp""
#include ""uml/ActivityGroup.hpp""
#include ""umlReflectionExec/ActivityGroupObject.hpp""
#include ""uml/InterruptibleActivityRegion.hpp""
#include ""umlReflectionExec/InterruptibleActivityRegionObject.hpp""
#include ""uml/ActivityPartition.hpp""
#include ""umlReflectionExec/ActivityPartitionObject.hpp""
#include ""uml/StructuredActivityNode.hpp""
#include ""umlReflectionExec/StructuredActivityNodeObject.hpp""
#include ""uml/ActivityEdge.hpp""
#include ""umlReflectionExec/ActivityEdgeObject.hpp""
#include ""uml/ActivityEdge.hpp""
#include ""umlReflectionExec/ActivityEdgeObject.hpp""
#include ""uml/ActivityNode.hpp""
#include ""umlReflectionExec/ActivityNodeObject.hpp""
#include ""uml/Comment.hpp""
#include ""umlReflectionExec/CommentObject.hpp""
#include ""uml/Element.hpp""
#include ""umlReflectionExec/ElementObject.hpp""
#include ""uml/Element.hpp""
#include ""umlReflectionExec/ElementObject.hpp""
#include ""uml/ExceptionHandler.hpp""
#include ""umlReflectionExec/ExceptionHandlerObject.hpp""
#include ""uml/Dependency.hpp""
#include ""umlReflectionExec/DependencyObject.hpp""
#include ""fUML/Semantics/SimpleClassifiers/StringValue.hpp""
#include ""uml/StringExpression.hpp""
#include ""umlReflectionExec/StringExpressionObject.hpp""
#include ""uml/Namespace.hpp""
#include ""umlReflectionExec/NamespaceObject.hpp""
#include ""fUML/Semantics/SimpleClassifiers/StringValue.hpp""
#include ""fUML/Semantics/SimpleClassifiers/EnumerationValue.hpp""
#include ""uml/VisibilityKind.hpp""
#include ""uml/InputPin.hpp""
#include ""umlReflectionExec/InputPinObject.hpp""
#include ""uml/Property.hpp""
#include ""umlReflectionExec/PropertyObject.hpp""
#include ""uml/OutputPin.hpp""
#include ""umlReflectionExec/OutputPinObject.hpp""
#include ""fUML/Semantics/SimpleClassifiers/BooleanValue.hpp""
#include ""uml/RedefinableElement.hpp""
#include ""umlReflectionExec/RedefinableElementObject.hpp""
#include ""uml/Classifier.hpp""
#include ""umlReflectionExec/ClassifierObject.hpp""
//Property Packages Includes
#include ""primitivetypesReflection/PrimitiveTypesPackage.hpp""


using namespace UML;

ReadLinkObjectEndQualifierActionObject::ReadLinkObjectEndQualifierActionObject(std::shared_ptr<uml::ReadLinkObjectEndQualifierAction> _element):

	m_ReadLinkObjectEndQualifierActionValue(_element)
{		
	this->getTypes()->insert(this->getTypes()->begin(), UML::UMLPackage::eInstance()->get_UML_ReadLinkObjectEndQualifierAction());
}

ReadLinkObjectEndQualifierActionObject::ReadLinkObjectEndQualifierActionObject(ReadLinkObjectEndQualifierActionObject &obj):
	CS_ObjectImpl(obj)
{
}

ReadLinkObjectEndQualifierActionObject::ReadLinkObjectEndQualifierActionObject()
{	
	this->getTypes()->insert(this->getTypes()->begin(), UML::UMLPackage::eInstance()->get_UML_ReadLinkObjectEndQualifierAction());
}

ReadLinkObjectEndQualifierActionObject::~ReadLinkObjectEndQualifierActionObject()
{
}

std::shared_ptr<ecore::EObject> ReadLinkObjectEndQualifierActionObject::copy()
{
	std::shared_ptr<ReadLinkObjectEndQualifierActionObject> element(new ReadLinkObjectEndQualifierActionObject(*this));
	element->setThisReadLinkObjectEndQualifierActionObjectPtr(element);
	return element;
}

void ReadLinkObjectEndQualifierActionObject::destroy()
{	
	m_ReadLinkObjectEndQualifierActionValue.reset();

	fUML::Semantics::StructuredClassifiers::ObjectImpl::destroy();
}

std::shared_ptr<uml::Element> ReadLinkObjectEndQualifierActionObject::getUmlValue() const
{
	return getReadLinkObjectEndQualifierActionValue();
}

std::shared_ptr<uml::ReadLinkObjectEndQualifierAction> ReadLinkObjectEndQualifierActionObject::getReadLinkObjectEndQualifierActionValue() const
{
	return m_ReadLinkObjectEndQualifierActionValue;
}

void ReadLinkObjectEndQualifierActionObject::setUmlValue(std::shared_ptr<uml::Element> _element)
{
	setReadLinkObjectEndQualifierActionValue(std::dynamic_pointer_cast<uml::ReadLinkObjectEndQualifierAction>(_element));
}

void ReadLinkObjectEndQualifierActionObject::setReadLinkObjectEndQualifierActionValue(std::shared_ptr<uml::ReadLinkObjectEndQualifierAction> _ReadLinkObjectEndQualifierActionElement)
{
	m_ReadLinkObjectEndQualifierActionValue = _ReadLinkObjectEndQualifierActionElement;
	//set super type values
	UML::ActionObject::setActionValue(_ReadLinkObjectEndQualifierActionElement);
}

void ReadLinkObjectEndQualifierActionObject::setThisReadLinkObjectEndQualifierActionObjectPtr(std::weak_ptr<ReadLinkObjectEndQualifierActionObject> thisObjectPtr)
{
	setThisCS_ObjectPtr(thisObjectPtr);
}

bool ReadLinkObjectEndQualifierActionObject::equals(std::shared_ptr<fUML::Semantics::Values::Value> otherValue)
{
	bool isEqual = false;
	
	std::shared_ptr<ReadLinkObjectEndQualifierActionObject> otherReadLinkObjectEndQualifierActionObject = std::dynamic_pointer_cast<ReadLinkObjectEndQualifierActionObject>(otherValue);

	if(otherReadLinkObjectEndQualifierActionObject != nullptr)
	{
		if(this->getReadLinkObjectEndQualifierActionValue() == otherReadLinkObjectEndQualifierActionObject->getReadLinkObjectEndQualifierActionValue())
		{
			isEqual = true;
		}
	}

	return isEqual;
}

std::string ReadLinkObjectEndQualifierActionObject::toString()
{
	std::string buffer = ""Instance of 'ReadLinkObjectEndQualifierActionObject', "" + std::to_string(getTypes()->size()) + "" types ("";
	for(unsigned int i = 0; i < getTypes()->size(); ++i)
	{
		buffer += ""type{"" + std::to_string(i) + ""}: '"" + getTypes()->at(i)->getName() + ""', "";
	}
	buffer +="")"";

	return buffer;
}

std::shared_ptr<Bag<PSCS::Semantics::StructuredClassifiers::CS_Object>> ReadLinkObjectEndQualifierActionObject::getDirectContainers()
{   
	std::shared_ptr<Bag<PSCS::Semantics::StructuredClassifiers::CS_Object>> directContainers(new Bag<PSCS::Semantics::StructuredClassifiers::CS_Object>());

	/*Not done for metamodel object classes*/

	return directContainers;
}

std::shared_ptr<Bag<PSCS::Semantics::StructuredClassifiers::CS_Link>> ReadLinkObjectEndQualifierActionObject::getLinks(std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_InteractionPoint> interactionPoint)
{
	std::shared_ptr<Bag<PSCS::Semantics::StructuredClassifiers::CS_Link>> allLinks(new Bag<PSCS::Semantics::StructuredClassifiers::CS_Link>());

	/*Not done for metamodel object classes*/

	return allLinks;
}

std::shared_ptr<Bag<fUML::Semantics::Values::Value>> ReadLinkObjectEndQualifierActionObject::retrieveEndValueAsInteractionPoint(std::shared_ptr<fUML::Semantics::Values::Value> endValue, std::shared_ptr<uml::ConnectorEnd> end)
{
	/*Not done for metamodel object classes*/

	return nullptr;
}

void ReadLinkObjectEndQualifierActionObject::removeValue(std::shared_ptr<uml::StructuralFeature> feature, std::shared_ptr<fUML::Semantics::Values::Value> value)
{
	if (feature->getMetaElementID() != uml::umlPackage::PROPERTY_CLASS && feature->getMetaElementID() != uml::umlPackage::PORT_CLASS && feature->getMetaElementID() != uml::umlPackage::EXTENSIONEND_CLASS)
	{
		std::cerr << __PRETTY_FUNCTION__ << "": feature is null or not kind of uml::Property"" << std::endl;
		throw ""feature is null or not kind of uml::Property"";
	}

	if (m_ReadLinkObjectEndQualifierActionValue == nullptr)
	{
		std::cerr << __PRETTY_FUNCTION__ << "": no value stored inside ReadLinkObjectEndQualifierActionObject (property: "" << feature->getName() << "")"" << std::endl;
		throw ""NullPointerException"";	
	}

	if (feature == UML::UMLPackage::eInstance()->get_UML_Action_isLocallyReentrant())
	{
				m_ReadLinkObjectEndQualifierActionValue->setIsLocallyReentrant(false /*defined default value*/);

	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_Action_localPostcondition())
	{
		if (value == nullptr) // clear mode
		{
			m_ReadLinkObjectEndQualifierActionValue->getLocalPostcondition()->clear();
		}
		else
		{
			/* Should use PSCS::CS_Reference but dynamic_pointer_cast fails --> using fUML::Reference instead
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(value); */
			std::shared_ptr<fUML::Semantics::StructuredClassifiers::Reference> reference = std::dynamic_pointer_cast<fUML::Semantics::StructuredClassifiers::Reference>(value);
			std::shared_ptr<UML::ConstraintObject> inputValue = std::dynamic_pointer_cast<UML::ConstraintObject>(reference->getReferent());
			if (inputValue != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getLocalPostcondition()->erase(inputValue->getConstraintValue());
			}
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_Action_localPrecondition())
	{
		if (value == nullptr) // clear mode
		{
			m_ReadLinkObjectEndQualifierActionValue->getLocalPrecondition()->clear();
		}
		else
		{
			/* Should use PSCS::CS_Reference but dynamic_pointer_cast fails --> using fUML::Reference instead
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(value); */
			std::shared_ptr<fUML::Semantics::StructuredClassifiers::Reference> reference = std::dynamic_pointer_cast<fUML::Semantics::StructuredClassifiers::Reference>(value);
			std::shared_ptr<UML::ConstraintObject> inputValue = std::dynamic_pointer_cast<UML::ConstraintObject>(reference->getReferent());
			if (inputValue != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getLocalPrecondition()->erase(inputValue->getConstraintValue());
			}
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_activity())
	{
				m_ReadLinkObjectEndQualifierActionValue->getActivity().reset();

	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_inInterruptibleRegion())
	{
		if (value == nullptr) // clear mode
		{
			m_ReadLinkObjectEndQualifierActionValue->getInInterruptibleRegion()->clear();
		}
		else
		{
			/* Should use PSCS::CS_Reference but dynamic_pointer_cast fails --> using fUML::Reference instead
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(value); */
			std::shared_ptr<fUML::Semantics::StructuredClassifiers::Reference> reference = std::dynamic_pointer_cast<fUML::Semantics::StructuredClassifiers::Reference>(value);
			std::shared_ptr<UML::InterruptibleActivityRegionObject> inputValue = std::dynamic_pointer_cast<UML::InterruptibleActivityRegionObject>(reference->getReferent());
			if (inputValue != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getInInterruptibleRegion()->erase(inputValue->getInterruptibleActivityRegionValue());
			}
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_inPartition())
	{
		if (value == nullptr) // clear mode
		{
			m_ReadLinkObjectEndQualifierActionValue->getInPartition()->clear();
		}
		else
		{
			/* Should use PSCS::CS_Reference but dynamic_pointer_cast fails --> using fUML::Reference instead
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(value); */
			std::shared_ptr<fUML::Semantics::StructuredClassifiers::Reference> reference = std::dynamic_pointer_cast<fUML::Semantics::StructuredClassifiers::Reference>(value);
			std::shared_ptr<UML::ActivityPartitionObject> inputValue = std::dynamic_pointer_cast<UML::ActivityPartitionObject>(reference->getReferent());
			if (inputValue != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getInPartition()->erase(inputValue->getActivityPartitionValue());
			}
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_inStructuredNode())
	{
				m_ReadLinkObjectEndQualifierActionValue->getInStructuredNode().reset();

	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_incoming())
	{
		if (value == nullptr) // clear mode
		{
			m_ReadLinkObjectEndQualifierActionValue->getIncoming()->clear();
		}
		else
		{
			/* Should use PSCS::CS_Reference but dynamic_pointer_cast fails --> using fUML::Reference instead
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(value); */
			std::shared_ptr<fUML::Semantics::StructuredClassifiers::Reference> reference = std::dynamic_pointer_cast<fUML::Semantics::StructuredClassifiers::Reference>(value);
			std::shared_ptr<UML::ActivityEdgeObject> inputValue = std::dynamic_pointer_cast<UML::ActivityEdgeObject>(reference->getReferent());
			if (inputValue != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getIncoming()->erase(inputValue->getActivityEdgeValue());
			}
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_outgoing())
	{
		if (value == nullptr) // clear mode
		{
			m_ReadLinkObjectEndQualifierActionValue->getOutgoing()->clear();
		}
		else
		{
			/* Should use PSCS::CS_Reference but dynamic_pointer_cast fails --> using fUML::Reference instead
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(value); */
			std::shared_ptr<fUML::Semantics::StructuredClassifiers::Reference> reference = std::dynamic_pointer_cast<fUML::Semantics::StructuredClassifiers::Reference>(value);
			std::shared_ptr<UML::ActivityEdgeObject> inputValue = std::dynamic_pointer_cast<UML::ActivityEdgeObject>(reference->getReferent());
			if (inputValue != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getOutgoing()->erase(inputValue->getActivityEdgeValue());
			}
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_redefinedNode())
	{
		if (value == nullptr) // clear mode
		{
			m_ReadLinkObjectEndQualifierActionValue->getRedefinedNode()->clear();
		}
		else
		{
			/* Should use PSCS::CS_Reference but dynamic_pointer_cast fails --> using fUML::Reference instead
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(value); */
			std::shared_ptr<fUML::Semantics::StructuredClassifiers::Reference> reference = std::dynamic_pointer_cast<fUML::Semantics::StructuredClassifiers::Reference>(value);
			std::shared_ptr<UML::ActivityNodeObject> inputValue = std::dynamic_pointer_cast<UML::ActivityNodeObject>(reference->getReferent());
			if (inputValue != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getRedefinedNode()->erase(inputValue->getActivityNodeValue());
			}
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_Element_ownedComment())
	{
		if (value == nullptr) // clear mode
		{
			m_ReadLinkObjectEndQualifierActionValue->getOwnedComment()->clear();
		}
		else
		{
			/* Should use PSCS::CS_Reference but dynamic_pointer_cast fails --> using fUML::Reference instead
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(value); */
			std::shared_ptr<fUML::Semantics::StructuredClassifiers::Reference> reference = std::dynamic_pointer_cast<fUML::Semantics::StructuredClassifiers::Reference>(value);
			std::shared_ptr<UML::CommentObject> inputValue = std::dynamic_pointer_cast<UML::CommentObject>(reference->getReferent());
			if (inputValue != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getOwnedComment()->erase(inputValue->getCommentValue());
			}
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ExecutableNode_handler())
	{
		if (value == nullptr) // clear mode
		{
			m_ReadLinkObjectEndQualifierActionValue->getHandler()->clear();
		}
		else
		{
			/* Should use PSCS::CS_Reference but dynamic_pointer_cast fails --> using fUML::Reference instead
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(value); */
			std::shared_ptr<fUML::Semantics::StructuredClassifiers::Reference> reference = std::dynamic_pointer_cast<fUML::Semantics::StructuredClassifiers::Reference>(value);
			std::shared_ptr<UML::ExceptionHandlerObject> inputValue = std::dynamic_pointer_cast<UML::ExceptionHandlerObject>(reference->getReferent());
			if (inputValue != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getHandler()->erase(inputValue->getExceptionHandlerValue());
			}
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_name())
	{
				// no default value defined, clear not realized

	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_nameExpression())
	{
				m_ReadLinkObjectEndQualifierActionValue->getNameExpression().reset();

	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_visibility())
	{
				// no default value defined, clear not realized

	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ReadLinkObjectEndQualifierAction_object())
	{
				m_ReadLinkObjectEndQualifierActionValue->getObject().reset();

	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ReadLinkObjectEndQualifierAction_qualifier())
	{
				m_ReadLinkObjectEndQualifierActionValue->getQualifier().reset();

	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ReadLinkObjectEndQualifierAction_result())
	{
				m_ReadLinkObjectEndQualifierActionValue->getResult().reset();

	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_RedefinableElement_isLeaf())
	{
				m_ReadLinkObjectEndQualifierActionValue->setIsLeaf(false /*defined default value*/);

	}
}


std::shared_ptr<Bag<fUML::Semantics::Values::Value>> ReadLinkObjectEndQualifierActionObject::getValues(std::shared_ptr<uml::StructuralFeature> feature, std::shared_ptr<Bag<fUML::Semantics::SimpleClassifiers::FeatureValue>> featureValues)
{
	if (feature->getMetaElementID() != uml::umlPackage::PROPERTY_CLASS && feature->getMetaElementID() != uml::umlPackage::PORT_CLASS && feature->getMetaElementID() != uml::umlPackage::EXTENSIONEND_CLASS)
	{
		std::cerr << __PRETTY_FUNCTION__ << "": feature is null or not kind of uml::Property"" << std::endl;
		throw ""feature is null or not kind of uml::Property"";
	}

	if (m_ReadLinkObjectEndQualifierActionValue == nullptr)
	{
		std::cerr << __PRETTY_FUNCTION__ << "": no value stored inside ReadLinkObjectEndQualifierActionObject (property: "" << feature->getName() << "")"" << std::endl;
		throw ""NullPointerException"";	
	}

	std::shared_ptr<Bag<fUML::Semantics::Values::Value>> values(new Bag<fUML::Semantics::Values::Value>());
	if (feature == UML::UMLPackage::eInstance()->get_UML_Action_context())
	{
		std::shared_ptr<UML::ClassifierObject> value(new UML::ClassifierObject());
		value->setThisClassifierObjectPtr(value);
		value->setLocus(this->getLocus());
		value->setClassifierValue(m_ReadLinkObjectEndQualifierActionValue->getContext());
		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
		reference->setReferent(value);
		values->add(reference);
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_Action_input())
	{
		std::shared_ptr<Bag<uml::InputPin>> inputList = m_ReadLinkObjectEndQualifierActionValue->getInput();
		Bag<uml::InputPin>::iterator iter = inputList->begin();
		Bag<uml::InputPin>::iterator end = inputList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::InputPinObject> value(new UML::InputPinObject());
			value->setThisInputPinObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setInputPinValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			reference->setCompositeReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_Action_isLocallyReentrant())
	{
		std::shared_ptr<fUML::Semantics::SimpleClassifiers::BooleanValue> value = fUML::Semantics::SimpleClassifiers::SimpleClassifiersFactory::eInstance()->createBooleanValue();
		value->setValue(m_ReadLinkObjectEndQualifierActionValue->getIsLocallyReentrant());
		values->add(value);
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_Action_localPostcondition())
	{
		std::shared_ptr<Bag<uml::Constraint>> localPostconditionList = m_ReadLinkObjectEndQualifierActionValue->getLocalPostcondition();
		Bag<uml::Constraint>::iterator iter = localPostconditionList->begin();
		Bag<uml::Constraint>::iterator end = localPostconditionList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::ConstraintObject> value(new UML::ConstraintObject());
			value->setThisConstraintObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setConstraintValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			reference->setCompositeReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_Action_localPrecondition())
	{
		std::shared_ptr<Bag<uml::Constraint>> localPreconditionList = m_ReadLinkObjectEndQualifierActionValue->getLocalPrecondition();
		Bag<uml::Constraint>::iterator iter = localPreconditionList->begin();
		Bag<uml::Constraint>::iterator end = localPreconditionList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::ConstraintObject> value(new UML::ConstraintObject());
			value->setThisConstraintObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setConstraintValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			reference->setCompositeReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_Action_output())
	{
		std::shared_ptr<Bag<uml::OutputPin>> outputList = m_ReadLinkObjectEndQualifierActionValue->getOutput();
		Bag<uml::OutputPin>::iterator iter = outputList->begin();
		Bag<uml::OutputPin>::iterator end = outputList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::OutputPinObject> value(new UML::OutputPinObject());
			value->setThisOutputPinObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setOutputPinValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			reference->setCompositeReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_activity())
	{
		std::shared_ptr<UML::ActivityObject> value(new UML::ActivityObject());
		value->setThisActivityObjectPtr(value);
		value->setLocus(this->getLocus());
		value->setActivityValue(m_ReadLinkObjectEndQualifierActionValue->getActivity().lock());
		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
		reference->setReferent(value);
		values->add(reference);
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_inGroup())
	{
		std::shared_ptr<Bag<uml::ActivityGroup>> inGroupList = m_ReadLinkObjectEndQualifierActionValue->getInGroup();
		Bag<uml::ActivityGroup>::iterator iter = inGroupList->begin();
		Bag<uml::ActivityGroup>::iterator end = inGroupList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::ActivityGroupObject> value(new UML::ActivityGroupObject());
			value->setThisActivityGroupObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setActivityGroupValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_inInterruptibleRegion())
	{
		std::shared_ptr<Bag<uml::InterruptibleActivityRegion>> inInterruptibleRegionList = m_ReadLinkObjectEndQualifierActionValue->getInInterruptibleRegion();
		Bag<uml::InterruptibleActivityRegion>::iterator iter = inInterruptibleRegionList->begin();
		Bag<uml::InterruptibleActivityRegion>::iterator end = inInterruptibleRegionList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::InterruptibleActivityRegionObject> value(new UML::InterruptibleActivityRegionObject());
			value->setThisInterruptibleActivityRegionObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setInterruptibleActivityRegionValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_inPartition())
	{
		std::shared_ptr<Bag<uml::ActivityPartition>> inPartitionList = m_ReadLinkObjectEndQualifierActionValue->getInPartition();
		Bag<uml::ActivityPartition>::iterator iter = inPartitionList->begin();
		Bag<uml::ActivityPartition>::iterator end = inPartitionList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::ActivityPartitionObject> value(new UML::ActivityPartitionObject());
			value->setThisActivityPartitionObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setActivityPartitionValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_inStructuredNode())
	{
		std::shared_ptr<UML::StructuredActivityNodeObject> value(new UML::StructuredActivityNodeObject());
		value->setThisStructuredActivityNodeObjectPtr(value);
		value->setLocus(this->getLocus());
		value->setStructuredActivityNodeValue(m_ReadLinkObjectEndQualifierActionValue->getInStructuredNode().lock());
		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
		reference->setReferent(value);
		values->add(reference);
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_incoming())
	{
		std::shared_ptr<Bag<uml::ActivityEdge>> incomingList = m_ReadLinkObjectEndQualifierActionValue->getIncoming();
		Bag<uml::ActivityEdge>::iterator iter = incomingList->begin();
		Bag<uml::ActivityEdge>::iterator end = incomingList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::ActivityEdgeObject> value(new UML::ActivityEdgeObject());
			value->setThisActivityEdgeObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setActivityEdgeValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_outgoing())
	{
		std::shared_ptr<Bag<uml::ActivityEdge>> outgoingList = m_ReadLinkObjectEndQualifierActionValue->getOutgoing();
		Bag<uml::ActivityEdge>::iterator iter = outgoingList->begin();
		Bag<uml::ActivityEdge>::iterator end = outgoingList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::ActivityEdgeObject> value(new UML::ActivityEdgeObject());
			value->setThisActivityEdgeObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setActivityEdgeValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_redefinedNode())
	{
		std::shared_ptr<Bag<uml::ActivityNode>> redefinedNodeList = m_ReadLinkObjectEndQualifierActionValue->getRedefinedNode();
		Bag<uml::ActivityNode>::iterator iter = redefinedNodeList->begin();
		Bag<uml::ActivityNode>::iterator end = redefinedNodeList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::ActivityNodeObject> value(new UML::ActivityNodeObject());
			value->setThisActivityNodeObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setActivityNodeValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_Element_ownedComment())
	{
		std::shared_ptr<Bag<uml::Comment>> ownedCommentList = m_ReadLinkObjectEndQualifierActionValue->getOwnedComment();
		Bag<uml::Comment>::iterator iter = ownedCommentList->begin();
		Bag<uml::Comment>::iterator end = ownedCommentList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::CommentObject> value(new UML::CommentObject());
			value->setThisCommentObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setCommentValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			reference->setCompositeReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_Element_ownedElement())
	{
		std::shared_ptr<Bag<uml::Element>> ownedElementList = m_ReadLinkObjectEndQualifierActionValue->getOwnedElement();
		Bag<uml::Element>::iterator iter = ownedElementList->begin();
		Bag<uml::Element>::iterator end = ownedElementList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::ElementObject> value(new UML::ElementObject());
			value->setThisElementObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setElementValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			reference->setCompositeReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_Element_owner())
	{
		std::shared_ptr<UML::ElementObject> value(new UML::ElementObject());
		value->setThisElementObjectPtr(value);
		value->setLocus(this->getLocus());
		value->setElementValue(m_ReadLinkObjectEndQualifierActionValue->getOwner().lock());
		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
		reference->setReferent(value);
		values->add(reference);
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ExecutableNode_handler())
	{
		std::shared_ptr<Bag<uml::ExceptionHandler>> handlerList = m_ReadLinkObjectEndQualifierActionValue->getHandler();
		Bag<uml::ExceptionHandler>::iterator iter = handlerList->begin();
		Bag<uml::ExceptionHandler>::iterator end = handlerList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::ExceptionHandlerObject> value(new UML::ExceptionHandlerObject());
			value->setThisExceptionHandlerObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setExceptionHandlerValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			reference->setCompositeReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_clientDependency())
	{
		std::shared_ptr<Bag<uml::Dependency>> clientDependencyList = m_ReadLinkObjectEndQualifierActionValue->getClientDependency();
		Bag<uml::Dependency>::iterator iter = clientDependencyList->begin();
		Bag<uml::Dependency>::iterator end = clientDependencyList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::DependencyObject> value(new UML::DependencyObject());
			value->setThisDependencyObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setDependencyValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_name())
	{
		std::shared_ptr<fUML::Semantics::SimpleClassifiers::StringValue> value = fUML::Semantics::SimpleClassifiers::SimpleClassifiersFactory::eInstance()->createStringValue();
		value->setValue(m_ReadLinkObjectEndQualifierActionValue->getName());
		values->add(value);
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_nameExpression())
	{
		std::shared_ptr<UML::StringExpressionObject> value(new UML::StringExpressionObject());
		value->setThisStringExpressionObjectPtr(value);
		value->setLocus(this->getLocus());
		value->setStringExpressionValue(m_ReadLinkObjectEndQualifierActionValue->getNameExpression());
		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
		reference->setReferent(value);
		reference->setCompositeReferent(value);
		values->add(reference);
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_namespace())
	{
		std::shared_ptr<UML::NamespaceObject> value(new UML::NamespaceObject());
		value->setThisNamespaceObjectPtr(value);
		value->setLocus(this->getLocus());
		value->setNamespaceValue(m_ReadLinkObjectEndQualifierActionValue->getNamespace().lock());
		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
		reference->setReferent(value);
		values->add(reference);
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_qualifiedName())
	{
		std::shared_ptr<fUML::Semantics::SimpleClassifiers::StringValue> value = fUML::Semantics::SimpleClassifiers::SimpleClassifiersFactory::eInstance()->createStringValue();
		value->setValue(m_ReadLinkObjectEndQualifierActionValue->getQualifiedName());
		values->add(value);
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_visibility())
	{
		uml::VisibilityKind visibility = m_ReadLinkObjectEndQualifierActionValue->getVisibility();
		std::shared_ptr<fUML::Semantics::SimpleClassifiers::EnumerationValue> value = fUML::Semantics::SimpleClassifiers::SimpleClassifiersFactory::eInstance()->createEnumerationValue();
		if (visibility == uml::VisibilityKind::PUBLIC)
		{
			value->setLiteral(UML::UMLPackage::eInstance()->get_UML_VisibilityKind_public());
		}
		if (visibility == uml::VisibilityKind::PRIVATE)
		{
			value->setLiteral(UML::UMLPackage::eInstance()->get_UML_VisibilityKind_private());
		}
		if (visibility == uml::VisibilityKind::PROTECTED)
		{
			value->setLiteral(UML::UMLPackage::eInstance()->get_UML_VisibilityKind_protected());
		}
		if (visibility == uml::VisibilityKind::PACKAGE)
		{
			value->setLiteral(UML::UMLPackage::eInstance()->get_UML_VisibilityKind_package());
		}
		values->add(value);
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ReadLinkObjectEndQualifierAction_object())
	{
		std::shared_ptr<UML::InputPinObject> value(new UML::InputPinObject());
		value->setThisInputPinObjectPtr(value);
		value->setLocus(this->getLocus());
		value->setInputPinValue(m_ReadLinkObjectEndQualifierActionValue->getObject());
		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
		reference->setReferent(value);
		reference->setCompositeReferent(value);
		values->add(reference);
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ReadLinkObjectEndQualifierAction_qualifier())
	{
		std::shared_ptr<UML::PropertyObject> value(new UML::PropertyObject());
		value->setThisPropertyObjectPtr(value);
		value->setLocus(this->getLocus());
		value->setPropertyValue(m_ReadLinkObjectEndQualifierActionValue->getQualifier());
		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
		reference->setReferent(value);
		values->add(reference);
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ReadLinkObjectEndQualifierAction_result())
	{
		std::shared_ptr<UML::OutputPinObject> value(new UML::OutputPinObject());
		value->setThisOutputPinObjectPtr(value);
		value->setLocus(this->getLocus());
		value->setOutputPinValue(m_ReadLinkObjectEndQualifierActionValue->getResult());
		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
		reference->setReferent(value);
		reference->setCompositeReferent(value);
		values->add(reference);
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_RedefinableElement_isLeaf())
	{
		std::shared_ptr<fUML::Semantics::SimpleClassifiers::BooleanValue> value = fUML::Semantics::SimpleClassifiers::SimpleClassifiersFactory::eInstance()->createBooleanValue();
		value->setValue(m_ReadLinkObjectEndQualifierActionValue->getIsLeaf());
		values->add(value);
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_RedefinableElement_redefinedElement())
	{
		std::shared_ptr<Bag<uml::RedefinableElement>> redefinedElementList = m_ReadLinkObjectEndQualifierActionValue->getRedefinedElement();
		Bag<uml::RedefinableElement>::iterator iter = redefinedElementList->begin();
		Bag<uml::RedefinableElement>::iterator end = redefinedElementList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::RedefinableElementObject> value(new UML::RedefinableElementObject());
			value->setThisRedefinableElementObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setRedefinableElementValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_RedefinableElement_redefinitionContext())
	{
		std::shared_ptr<Bag<uml::Classifier>> redefinitionContextList = m_ReadLinkObjectEndQualifierActionValue->getRedefinitionContext();
		Bag<uml::Classifier>::iterator iter = redefinitionContextList->begin();
		Bag<uml::Classifier>::iterator end = redefinitionContextList->end();
		while (iter != end)
		{
			std::shared_ptr<UML::ClassifierObject> value(new UML::ClassifierObject());
			value->setThisClassifierObjectPtr(value);
			value->setLocus(this->getLocus());
			value->setClassifierValue(*iter);
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = PSCS::Semantics::StructuredClassifiers::StructuredClassifiersFactory::eInstance()->createCS_Reference();
			reference->setReferent(value);
			values->add(reference);
			iter++;
		} 
	}
	return values;
}

std::shared_ptr<fUML::Semantics::SimpleClassifiers::FeatureValue> ReadLinkObjectEndQualifierActionObject::retrieveFeatureValue(std::shared_ptr<uml::StructuralFeature> feature)
{
	std::shared_ptr<fUML::Semantics::SimpleClassifiers::FeatureValue> featureValue(fUML::Semantics::SimpleClassifiers::SimpleClassifiersFactory::eInstance()->createFeatureValue());
	featureValue->setFeature(feature);

	std::shared_ptr<Bag<fUML::Semantics::SimpleClassifiers::FeatureValue>> featureValues(new Bag<fUML::Semantics::SimpleClassifiers::FeatureValue>());
	std::shared_ptr<Bag<fUML::Semantics::Values::Value>> values = this->getValues(feature, featureValues);
	
	unsigned int valuesSize = values->size();
	for(unsigned int i = 0; i < valuesSize; i++)
	{
		featureValue->getValues()->add(values->at(i));
	}

	return featureValue;
}


void ReadLinkObjectEndQualifierActionObject::setFeatureValue(std::shared_ptr<uml::StructuralFeature> feature, std::shared_ptr<Bag<fUML::Semantics::Values::Value>> values, int position)
{
	if (feature->getMetaElementID() != uml::umlPackage::PROPERTY_CLASS && feature->getMetaElementID() != uml::umlPackage::PORT_CLASS && feature->getMetaElementID() != uml::umlPackage::EXTENSIONEND_CLASS)
	{
		std::cerr << __PRETTY_FUNCTION__ << "": feature is null or not kind of uml::Property"" << std::endl;
		throw ""feature is null or not kind of uml::Property"";
	}

	if (m_ReadLinkObjectEndQualifierActionValue == nullptr)
	{
		std::cerr << __PRETTY_FUNCTION__ << "": no value stored inside ReadLinkObjectEndQualifierActionObject (property: "" << feature->getName() << "")"" << std::endl;
		throw ""NullPointerException"";	
	}

	if (values->size() == 0)
	{
		std::cout << __PRETTY_FUNCTION__ << "": no input value given"" << std::endl;
		return;
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_Action_isLocallyReentrant())
	{
		std::shared_ptr<fUML::Semantics::Values::Value> inputValue = values->at(0);
		std::shared_ptr<fUML::Semantics::SimpleClassifiers::BooleanValue> valueObject = std::dynamic_pointer_cast<fUML::Semantics::SimpleClassifiers::BooleanValue>(inputValue);
		if (valueObject != nullptr)
		{
			m_ReadLinkObjectEndQualifierActionValue->setIsLocallyReentrant(valueObject->isValue());
		}
		
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_Action_localPostcondition())
	{
		Bag<fUML::Semantics::Values::Value>::iterator iter = values->begin();
		Bag<fUML::Semantics::Values::Value>::iterator end = values->end();
		m_ReadLinkObjectEndQualifierActionValue->getLocalPostcondition()->clear();
		while (iter != end)
		{
			std::shared_ptr<fUML::Semantics::Values::Value> inputValue = *iter;
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
			std::shared_ptr<UML::ConstraintObject> value = std::dynamic_pointer_cast<UML::ConstraintObject>(reference->getReferent());
			if (value != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getLocalPostcondition()->push_back(value->getConstraintValue());
			}
			
			iter++;
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_Action_localPrecondition())
	{
		Bag<fUML::Semantics::Values::Value>::iterator iter = values->begin();
		Bag<fUML::Semantics::Values::Value>::iterator end = values->end();
		m_ReadLinkObjectEndQualifierActionValue->getLocalPrecondition()->clear();
		while (iter != end)
		{
			std::shared_ptr<fUML::Semantics::Values::Value> inputValue = *iter;
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
			std::shared_ptr<UML::ConstraintObject> value = std::dynamic_pointer_cast<UML::ConstraintObject>(reference->getReferent());
			if (value != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getLocalPrecondition()->push_back(value->getConstraintValue());
			}
			
			iter++;
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_inInterruptibleRegion())
	{
		Bag<fUML::Semantics::Values::Value>::iterator iter = values->begin();
		Bag<fUML::Semantics::Values::Value>::iterator end = values->end();
		m_ReadLinkObjectEndQualifierActionValue->getInInterruptibleRegion()->clear();
		while (iter != end)
		{
			std::shared_ptr<fUML::Semantics::Values::Value> inputValue = *iter;
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
			std::shared_ptr<UML::InterruptibleActivityRegionObject> value = std::dynamic_pointer_cast<UML::InterruptibleActivityRegionObject>(reference->getReferent());
			if (value != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getInInterruptibleRegion()->push_back(value->getInterruptibleActivityRegionValue());
			}
			
			iter++;
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_inPartition())
	{
		Bag<fUML::Semantics::Values::Value>::iterator iter = values->begin();
		Bag<fUML::Semantics::Values::Value>::iterator end = values->end();
		m_ReadLinkObjectEndQualifierActionValue->getInPartition()->clear();
		while (iter != end)
		{
			std::shared_ptr<fUML::Semantics::Values::Value> inputValue = *iter;
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
			std::shared_ptr<UML::ActivityPartitionObject> value = std::dynamic_pointer_cast<UML::ActivityPartitionObject>(reference->getReferent());
			if (value != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getInPartition()->push_back(value->getActivityPartitionValue());
			}
			
			iter++;
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_incoming())
	{
		Bag<fUML::Semantics::Values::Value>::iterator iter = values->begin();
		Bag<fUML::Semantics::Values::Value>::iterator end = values->end();
		m_ReadLinkObjectEndQualifierActionValue->getIncoming()->clear();
		while (iter != end)
		{
			std::shared_ptr<fUML::Semantics::Values::Value> inputValue = *iter;
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
			std::shared_ptr<UML::ActivityEdgeObject> value = std::dynamic_pointer_cast<UML::ActivityEdgeObject>(reference->getReferent());
			if (value != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getIncoming()->push_back(value->getActivityEdgeValue());
			}
			
			iter++;
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_outgoing())
	{
		Bag<fUML::Semantics::Values::Value>::iterator iter = values->begin();
		Bag<fUML::Semantics::Values::Value>::iterator end = values->end();
		m_ReadLinkObjectEndQualifierActionValue->getOutgoing()->clear();
		while (iter != end)
		{
			std::shared_ptr<fUML::Semantics::Values::Value> inputValue = *iter;
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
			std::shared_ptr<UML::ActivityEdgeObject> value = std::dynamic_pointer_cast<UML::ActivityEdgeObject>(reference->getReferent());
			if (value != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getOutgoing()->push_back(value->getActivityEdgeValue());
			}
			
			iter++;
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ActivityNode_redefinedNode())
	{
		Bag<fUML::Semantics::Values::Value>::iterator iter = values->begin();
		Bag<fUML::Semantics::Values::Value>::iterator end = values->end();
		m_ReadLinkObjectEndQualifierActionValue->getRedefinedNode()->clear();
		while (iter != end)
		{
			std::shared_ptr<fUML::Semantics::Values::Value> inputValue = *iter;
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
			std::shared_ptr<UML::ActivityNodeObject> value = std::dynamic_pointer_cast<UML::ActivityNodeObject>(reference->getReferent());
			if (value != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getRedefinedNode()->push_back(value->getActivityNodeValue());
			}
			
			iter++;
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_Element_ownedComment())
	{
		Bag<fUML::Semantics::Values::Value>::iterator iter = values->begin();
		Bag<fUML::Semantics::Values::Value>::iterator end = values->end();
		m_ReadLinkObjectEndQualifierActionValue->getOwnedComment()->clear();
		while (iter != end)
		{
			std::shared_ptr<fUML::Semantics::Values::Value> inputValue = *iter;
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
			std::shared_ptr<UML::CommentObject> value = std::dynamic_pointer_cast<UML::CommentObject>(reference->getReferent());
			if (value != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getOwnedComment()->push_back(value->getCommentValue());
			}
			
			iter++;
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ExecutableNode_handler())
	{
		Bag<fUML::Semantics::Values::Value>::iterator iter = values->begin();
		Bag<fUML::Semantics::Values::Value>::iterator end = values->end();
		m_ReadLinkObjectEndQualifierActionValue->getHandler()->clear();
		while (iter != end)
		{
			std::shared_ptr<fUML::Semantics::Values::Value> inputValue = *iter;
			std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
			std::shared_ptr<UML::ExceptionHandlerObject> value = std::dynamic_pointer_cast<UML::ExceptionHandlerObject>(reference->getReferent());
			if (value != nullptr)
			{
				m_ReadLinkObjectEndQualifierActionValue->getHandler()->push_back(value->getExceptionHandlerValue());
			}
			
			iter++;
		}
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_name())
	{
		std::shared_ptr<fUML::Semantics::Values::Value> inputValue = values->at(0);
		std::shared_ptr<fUML::Semantics::SimpleClassifiers::StringValue> valueObject = std::dynamic_pointer_cast<fUML::Semantics::SimpleClassifiers::StringValue>(inputValue);
		if (valueObject != nullptr)
		{
			m_ReadLinkObjectEndQualifierActionValue->setName(valueObject->getValue());
		}
		
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_nameExpression())
	{
		std::shared_ptr<fUML::Semantics::Values::Value> inputValue = values->at(0);
		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
		std::shared_ptr<UML::StringExpressionObject> value = std::dynamic_pointer_cast<UML::StringExpressionObject>(reference->getReferent());
		if (value != nullptr)
		{
			m_ReadLinkObjectEndQualifierActionValue->setNameExpression(value->getStringExpressionValue());
		}
		
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_NamedElement_visibility())
	{
		std::shared_ptr<fUML::Semantics::Values::Value> inputValue = values->at(0);
		std::shared_ptr<fUML::Semantics::SimpleClassifiers::EnumerationValue> enumValue = std::dynamic_pointer_cast<fUML::Semantics::SimpleClassifiers::EnumerationValue>(inputValue);
		std::shared_ptr<uml::EnumerationLiteral> literal = enumValue->getLiteral();
		if (literal == UML::UMLPackage::eInstance()->get_UML_VisibilityKind_public())
		{
			m_ReadLinkObjectEndQualifierActionValue->setVisibility(uml::VisibilityKind::PUBLIC);
		}
		if (literal == UML::UMLPackage::eInstance()->get_UML_VisibilityKind_private())
		{
			m_ReadLinkObjectEndQualifierActionValue->setVisibility(uml::VisibilityKind::PRIVATE);
		}
		if (literal == UML::UMLPackage::eInstance()->get_UML_VisibilityKind_protected())
		{
			m_ReadLinkObjectEndQualifierActionValue->setVisibility(uml::VisibilityKind::PROTECTED);
		}
		if (literal == UML::UMLPackage::eInstance()->get_UML_VisibilityKind_package())
		{
			m_ReadLinkObjectEndQualifierActionValue->setVisibility(uml::VisibilityKind::PACKAGE);
		}
		
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ReadLinkObjectEndQualifierAction_object())
	{
		std::shared_ptr<fUML::Semantics::Values::Value> inputValue = values->at(0);
		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
		std::shared_ptr<UML::InputPinObject> value = std::dynamic_pointer_cast<UML::InputPinObject>(reference->getReferent());
		if (value != nullptr)
		{
			m_ReadLinkObjectEndQualifierActionValue->setObject(value->getInputPinValue());
		}
		
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ReadLinkObjectEndQualifierAction_qualifier())
	{
		std::shared_ptr<fUML::Semantics::Values::Value> inputValue = values->at(0);
		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
		std::shared_ptr<UML::PropertyObject> value = std::dynamic_pointer_cast<UML::PropertyObject>(reference->getReferent());
		if (value != nullptr)
		{
			m_ReadLinkObjectEndQualifierActionValue->setQualifier(value->getPropertyValue());
		}
		
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_ReadLinkObjectEndQualifierAction_result())
	{
		std::shared_ptr<fUML::Semantics::Values::Value> inputValue = values->at(0);
		std::shared_ptr<PSCS::Semantics::StructuredClassifiers::CS_Reference> reference = std::dynamic_pointer_cast<PSCS::Semantics::StructuredClassifiers::CS_Reference>(inputValue);
		std::shared_ptr<UML::OutputPinObject> value = std::dynamic_pointer_cast<UML::OutputPinObject>(reference->getReferent());
		if (value != nullptr)
		{
			m_ReadLinkObjectEndQualifierActionValue->setResult(value->getOutputPinValue());
		}
		
	}
	if (feature == UML::UMLPackage::eInstance()->get_UML_RedefinableElement_isLeaf())
	{
		std::shared_ptr<fUML::Semantics::Values::Value> inputValue = values->at(0);
		std::shared_ptr<fUML::Semantics::SimpleClassifiers::BooleanValue> valueObject = std::dynamic_pointer_cast<fUML::Semantics::SimpleClassifiers::BooleanValue>(inputValue);
		if (valueObject != nullptr)
		{
			m_ReadLinkObjectEndQualifierActionValue->setIsLeaf(valueObject->isValue());
		}
		
	}
}

void ReadLinkObjectEndQualifierActionObject::assignFeatureValue(std::shared_ptr<uml::StructuralFeature> feature, std::shared_ptr<Bag<fUML::Semantics::Values::Value>> values, int position)
{
	this->setFeatureValue(feature, values, position);
}

std::shared_ptr<Bag<fUML::Semantics::SimpleClassifiers::FeatureValue>> ReadLinkObjectEndQualifierActionObject::retrieveFeatureValues()
{
	std::shared_ptr<uml::Classifier> type = this->getTypes()->at(0);
	std::shared_ptr<Bag<uml::Property>> allAttributes = type->getAllAttributes();
	std::shared_ptr<Bag<fUML::Semantics::SimpleClassifiers::FeatureValue>> featureValues(new Bag<fUML::Semantics::SimpleClassifiers::FeatureValue>());
	
	unsigned int allAttributesSize = allAttributes->size();

	for(unsigned int i = 0; i < allAttributesSize; i++)
	{
		std::shared_ptr<uml::Property> property = allAttributes->at(i);
		if (property == UML::UMLPackage::eInstance()->get_UML_Action_context() && m_ReadLinkObjectEndQualifierActionValue->getContext() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_Action_input() && m_ReadLinkObjectEndQualifierActionValue->getInput() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_Action_localPostcondition() && m_ReadLinkObjectEndQualifierActionValue->getLocalPostcondition() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_Action_localPrecondition() && m_ReadLinkObjectEndQualifierActionValue->getLocalPrecondition() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_Action_output() && m_ReadLinkObjectEndQualifierActionValue->getOutput() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_ActivityNode_activity() && m_ReadLinkObjectEndQualifierActionValue->getActivity().lock() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_ActivityNode_inGroup() && m_ReadLinkObjectEndQualifierActionValue->getInGroup() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_ActivityNode_inInterruptibleRegion() && m_ReadLinkObjectEndQualifierActionValue->getInInterruptibleRegion() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_ActivityNode_inPartition() && m_ReadLinkObjectEndQualifierActionValue->getInPartition() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_ActivityNode_inStructuredNode() && m_ReadLinkObjectEndQualifierActionValue->getInStructuredNode().lock() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_ActivityNode_incoming() && m_ReadLinkObjectEndQualifierActionValue->getIncoming() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_ActivityNode_outgoing() && m_ReadLinkObjectEndQualifierActionValue->getOutgoing() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_ActivityNode_redefinedNode() && m_ReadLinkObjectEndQualifierActionValue->getRedefinedNode() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_Element_ownedComment() && m_ReadLinkObjectEndQualifierActionValue->getOwnedComment() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_Element_ownedElement() && m_ReadLinkObjectEndQualifierActionValue->getOwnedElement() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_Element_owner() && m_ReadLinkObjectEndQualifierActionValue->getOwner().lock() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_ExecutableNode_handler() && m_ReadLinkObjectEndQualifierActionValue->getHandler() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_NamedElement_clientDependency() && m_ReadLinkObjectEndQualifierActionValue->getClientDependency() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_NamedElement_nameExpression() && m_ReadLinkObjectEndQualifierActionValue->getNameExpression() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_NamedElement_namespace() && m_ReadLinkObjectEndQualifierActionValue->getNamespace().lock() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_ReadLinkObjectEndQualifierAction_object() && m_ReadLinkObjectEndQualifierActionValue->getObject() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_ReadLinkObjectEndQualifierAction_qualifier() && m_ReadLinkObjectEndQualifierActionValue->getQualifier() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_ReadLinkObjectEndQualifierAction_result() && m_ReadLinkObjectEndQualifierActionValue->getResult() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_RedefinableElement_redefinedElement() && m_ReadLinkObjectEndQualifierActionValue->getRedefinedElement() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
		if (property == UML::UMLPackage::eInstance()->get_UML_RedefinableElement_redefinitionContext() && m_ReadLinkObjectEndQualifierActionValue->getRedefinitionContext() != nullptr)
		{
			featureValues->add(this->retrieveFeatureValue(property));
		}
	}
	
	return featureValues;
}

",16348,True,4482.173271921324,median
"// Copyright 2016 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include ""src/regexp/regexp-parser.h""

#include <vector>

#include ""src/execution/isolate.h""
#include ""src/heap/factory.h""
#include ""src/objects/objects-inl.h""
#include ""src/regexp/property-sequences.h""
#include ""src/regexp/regexp-macro-assembler.h""
#include ""src/regexp/regexp.h""
#include ""src/strings/char-predicates-inl.h""
#include ""src/utils/ostreams.h""
#include ""src/utils/utils.h""
#include ""src/zone/zone-list-inl.h""

#ifdef V8_INTL_SUPPORT
#include ""unicode/uniset.h""
#endif  // V8_INTL_SUPPORT

namespace v8 {
namespace internal {

RegExpParser::RegExpParser(FlatStringReader* in, JSRegExp::Flags flags,
                           Isolate* isolate, Zone* zone)
    : isolate_(isolate),
      zone_(zone),
      captures_(nullptr),
      named_captures_(nullptr),
      named_back_references_(nullptr),
      in_(in),
      current_(kEndMarker),
      top_level_flags_(flags),
      next_pos_(0),
      captures_started_(0),
      capture_count_(0),
      has_more_(true),
      simple_(false),
      contains_anchor_(false),
      is_scanned_for_captures_(false),
      has_named_captures_(false),
      failed_(false) {
  Advance();
}

template <bool update_position>
inline uc32 RegExpParser::ReadNext() {
  int position = next_pos_;
  uc32 c0 = in()->Get(position);
  position++;
  // Read the whole surrogate pair in case of unicode flag, if possible.
  if (unicode() && position < in()->length() &&
      unibrow::Utf16::IsLeadSurrogate(static_cast<uc16>(c0))) {
    uc16 c1 = in()->Get(position);
    if (unibrow::Utf16::IsTrailSurrogate(c1)) {
      c0 = unibrow::Utf16::CombineSurrogatePair(static_cast<uc16>(c0), c1);
      position++;
    }
  }
  if (update_position) next_pos_ = position;
  return c0;
}


uc32 RegExpParser::Next() {
  if (has_next()) {
    return ReadNext<false>();
  } else {
    return kEndMarker;
  }
}

void RegExpParser::Advance() {
  if (has_next()) {
    StackLimitCheck check(isolate());
    if (check.HasOverflowed()) {
      if (FLAG_correctness_fuzzer_suppressions) {
        FATAL(""Aborting on stack overflow"");
      }
      ReportError(RegExpError::kStackOverflow);
    } else if (zone()->excess_allocation()) {
      if (FLAG_correctness_fuzzer_suppressions) {
        FATAL(""Aborting on excess zone allocation"");
      }
      ReportError(RegExpError::kTooLarge);
    } else {
      current_ = ReadNext<true>();
    }
  } else {
    current_ = kEndMarker;
    // Advance so that position() points to 1-after-the-last-character. This is
    // important so that Reset() to this position works correctly.
    next_pos_ = in()->length() + 1;
    has_more_ = false;
  }
}


void RegExpParser::Reset(int pos) {
  next_pos_ = pos;
  has_more_ = (pos < in()->length());
  Advance();
}

void RegExpParser::Advance(int dist) {
  next_pos_ += dist - 1;
  Advance();
}


bool RegExpParser::simple() { return simple_; }

bool RegExpParser::IsSyntaxCharacterOrSlash(uc32 c) {
  switch (c) {
    case '^':
    case '$':
    case '\\\\':
    case '.':
    case '*':
    case '+':
    case '?':
    case '(':
    case ')':
    case '[':
    case ']':
    case '{':
    case '}':
    case '|':
    case '/':
      return true;
    default:
      break;
  }
  return false;
}

RegExpTree* RegExpParser::ReportError(RegExpError error) {
  if (failed_) return nullptr;  // Do not overwrite any existing error.
  failed_ = true;
  error_ = error;
  error_pos_ = position();
  // Zip to the end to make sure no more input is read.
  current_ = kEndMarker;
  next_pos_ = in()->length();
  return nullptr;
}

#define CHECK_FAILED /**/);    \\
  if (failed_) return nullptr; \\
  ((void)0

// Pattern ::
//   Disjunction
RegExpTree* RegExpParser::ParsePattern() {
  RegExpTree* result = ParseDisjunction(CHECK_FAILED);
  PatchNamedBackReferences(CHECK_FAILED);
  DCHECK(!has_more());
  // If the result of parsing is a literal string atom, and it has the
  // same length as the input, then the atom is identical to the input.
  if (result->IsAtom() && result->AsAtom()->length() == in()->length()) {
    simple_ = true;
  }
  return result;
}


// Disjunction ::
//   Alternative
//   Alternative | Disjunction
// Alternative ::
//   [empty]
//   Term Alternative
// Term ::
//   Assertion
//   Atom
//   Atom Quantifier
RegExpTree* RegExpParser::ParseDisjunction() {
  // Used to store current state while parsing subexpressions.
  RegExpParserState initial_state(nullptr, INITIAL, RegExpLookaround::LOOKAHEAD,
                                  0, nullptr, top_level_flags_, zone());
  RegExpParserState* state = &initial_state;
  // Cache the builder in a local variable for quick access.
  RegExpBuilder* builder = initial_state.builder();
  while (true) {
    switch (current()) {
      case kEndMarker:
        if (state->IsSubexpression()) {
          // Inside a parenthesized group when hitting end of input.
          return ReportError(RegExpError::kUnterminatedGroup);
        }
        DCHECK_EQ(INITIAL, state->group_type());
        // Parsing completed successfully.
        return builder->ToRegExp();
      case ')': {
        if (!state->IsSubexpression()) {
          return ReportError(RegExpError::kUnmatchedParen);
        }
        DCHECK_NE(INITIAL, state->group_type());

        Advance();
        // End disjunction parsing and convert builder content to new single
        // regexp atom.
        RegExpTree* body = builder->ToRegExp();

        int end_capture_index = captures_started();

        int capture_index = state->capture_index();
        SubexpressionType group_type = state->group_type();

        // Build result of subexpression.
        if (group_type == CAPTURE) {
          if (state->IsNamedCapture()) {
            CreateNamedCaptureAtIndex(state->capture_name(),
                                      capture_index CHECK_FAILED);
          }
          RegExpCapture* capture = GetCapture(capture_index);
          capture->set_body(body);
          body = capture;
        } else if (group_type == GROUPING) {
          body = zone()->New<RegExpGroup>(body);
        } else {
          DCHECK(group_type == POSITIVE_LOOKAROUND ||
                 group_type == NEGATIVE_LOOKAROUND);
          bool is_positive = (group_type == POSITIVE_LOOKAROUND);
          body = zone()->New<RegExpLookaround>(
              body, is_positive, end_capture_index - capture_index,
              capture_index, state->lookaround_type());
        }

        // Restore previous state.
        state = state->previous_state();
        builder = state->builder();

        builder->AddAtom(body);
        // For compatibility with JSC and ES3, we allow quantifiers after
        // lookaheads, and break in all cases.
        break;
      }
      case '|': {
        Advance();
        builder->NewAlternative();
        continue;
      }
      case '*':
      case '+':
      case '?':
        return ReportError(RegExpError::kNothingToRepeat);
      case '^': {
        Advance();
        if (builder->multiline()) {
          builder->AddAssertion(zone()->New<RegExpAssertion>(
              RegExpAssertion::START_OF_LINE, builder->flags()));
        } else {
          builder->AddAssertion(zone()->New<RegExpAssertion>(
              RegExpAssertion::START_OF_INPUT, builder->flags()));
          set_contains_anchor();
        }
        continue;
      }
      case '$': {
        Advance();
        RegExpAssertion::AssertionType assertion_type =
            builder->multiline() ? RegExpAssertion::END_OF_LINE
                                 : RegExpAssertion::END_OF_INPUT;
        builder->AddAssertion(
            zone()->New<RegExpAssertion>(assertion_type, builder->flags()));
        continue;
      }
      case '.': {
        Advance();
        ZoneList<CharacterRange>* ranges =
            zone()->New<ZoneList<CharacterRange>>(2, zone());

        if (builder->dotall()) {
          // Everything.
          CharacterRange::AddClassEscape('*', ranges, false, zone());
        } else {
          // Everything except \\x0A, \\x0D, \\u2028 and \\u2029
          CharacterRange::AddClassEscape('.', ranges, false, zone());
        }

        RegExpCharacterClass* cc =
            zone()->New<RegExpCharacterClass>(zone(), ranges, builder->flags());
        builder->AddCharacterClass(cc);
        break;
      }
      case '(': {
        state = ParseOpenParenthesis(state CHECK_FAILED);
        builder = state->builder();
        continue;
      }
      case '[': {
        RegExpTree* cc = ParseCharacterClass(builder CHECK_FAILED);
        builder->AddCharacterClass(cc->AsCharacterClass());
        break;
      }
      // Atom ::
      //   \\ AtomEscape
      case '\\\\':
        switch (Next()) {
          case kEndMarker:
            return ReportError(RegExpError::kEscapeAtEndOfPattern);
          case 'b':
            Advance(2);
            builder->AddAssertion(zone()->New<RegExpAssertion>(
                RegExpAssertion::BOUNDARY, builder->flags()));
            continue;
          case 'B':
            Advance(2);
            builder->AddAssertion(zone()->New<RegExpAssertion>(
                RegExpAssertion::NON_BOUNDARY, builder->flags()));
            continue;
          // AtomEscape ::
          //   CharacterClassEscape
          //
          // CharacterClassEscape :: one of
          //   d D s S w W
          case 'd':
          case 'D':
          case 's':
          case 'S':
          case 'w':
          case 'W': {
            uc32 c = Next();
            Advance(2);
            ZoneList<CharacterRange>* ranges =
                zone()->New<ZoneList<CharacterRange>>(2, zone());
            CharacterRange::AddClassEscape(
                c, ranges, unicode() && builder->ignore_case(), zone());
            RegExpCharacterClass* cc = zone()->New<RegExpCharacterClass>(
                zone(), ranges, builder->flags());
            builder->AddCharacterClass(cc);
            break;
          }
          case 'p':
          case 'P': {
            uc32 p = Next();
            Advance(2);
            if (unicode()) {
              ZoneList<CharacterRange>* ranges =
                  zone()->New<ZoneList<CharacterRange>>(2, zone());
              ZoneVector<char> name_1(zone());
              ZoneVector<char> name_2(zone());
              if (ParsePropertyClassName(&name_1, &name_2)) {
                if (AddPropertyClassRange(ranges, p == 'P', name_1, name_2)) {
                  RegExpCharacterClass* cc = zone()->New<RegExpCharacterClass>(
                      zone(), ranges, builder->flags());
                  builder->AddCharacterClass(cc);
                  break;
                }
                if (p == 'p' && name_2.empty()) {
                  RegExpTree* sequence = GetPropertySequence(name_1);
                  if (sequence != nullptr) {
                    builder->AddAtom(sequence);
                    break;
                  }
                }
              }
              return ReportError(RegExpError::kInvalidPropertyName);
            } else {
              builder->AddCharacter(p);
            }
            break;
          }
          case '1':
          case '2':
          case '3':
          case '4':
          case '5':
          case '6':
          case '7':
          case '8':
          case '9': {
            int index = 0;
            bool is_backref = ParseBackReferenceIndex(&index CHECK_FAILED);
            if (is_backref) {
              if (state->IsInsideCaptureGroup(index)) {
                // The back reference is inside the capture group it refers to.
                // Nothing can possibly have been captured yet, so we use empty
                // instead. This ensures that, when checking a back reference,
                // the capture registers of the referenced capture are either
                // both set or both cleared.
                builder->AddEmpty();
              } else {
                RegExpCapture* capture = GetCapture(index);
                RegExpTree* atom =
                    zone()->New<RegExpBackReference>(capture, builder->flags());
                builder->AddAtom(atom);
              }
              break;
            }
            // With /u, no identity escapes except for syntax characters
            // are allowed. Otherwise, all identity escapes are allowed.
            if (unicode()) {
              return ReportError(RegExpError::kInvalidEscape);
            }
            uc32 first_digit = Next();
            if (first_digit == '8' || first_digit == '9') {
              builder->AddCharacter(first_digit);
              Advance(2);
              break;
            }
            V8_FALLTHROUGH;
          }
          case '0': {
            Advance();
            if (unicode() && Next() >= '0' && Next() <= '9') {
              // With /u, decimal escape with leading 0 are not parsed as octal.
              return ReportError(RegExpError::kInvalidDecimalEscape);
            }
            uc32 octal = ParseOctalLiteral();
            builder->AddCharacter(octal);
            break;
          }
          // ControlEscape :: one of
          //   f n r t v
          case 'f':
            Advance(2);
            builder->AddCharacter('\\f');
            break;
          case 'n':
            Advance(2);
            builder->AddCharacter('\\n');
            break;
          case 'r':
            Advance(2);
            builder->AddCharacter('\\r');
            break;
          case 't':
            Advance(2);
            builder->AddCharacter('\\t');
            break;
          case 'v':
            Advance(2);
            builder->AddCharacter('\\v');
            break;
          case 'c': {
            Advance();
            uc32 controlLetter = Next();
            // Special case if it is an ASCII letter.
            // Convert lower case letters to uppercase.
            uc32 letter = controlLetter & ~('a' ^ 'A');
            if (letter < 'A' || 'Z' < letter) {
              // controlLetter is not in range 'A'-'Z' or 'a'-'z'.
              // Read the backslash as a literal character instead of as
              // starting an escape.
              // ES#prod-annexB-ExtendedPatternCharacter
              if (unicode()) {
                // With /u, invalid escapes are not treated as identity escapes.
                return ReportError(RegExpError::kInvalidUnicodeEscape);
              }
              builder->AddCharacter('\\\\');
            } else {
              Advance(2);
              builder->AddCharacter(controlLetter & 0x1F);
            }
            break;
          }
          case 'x': {
            Advance(2);
            uc32 value;
            if (ParseHexEscape(2, &value)) {
              builder->AddCharacter(value);
            } else if (!unicode()) {
              builder->AddCharacter('x');
            } else {
              // With /u, invalid escapes are not treated as identity escapes.
              return ReportError(RegExpError::kInvalidEscape);
            }
            break;
          }
          case 'u': {
            Advance(2);
            uc32 value;
            if (ParseUnicodeEscape(&value)) {
              builder->AddEscapedUnicodeCharacter(value);
            } else if (!unicode()) {
              builder->AddCharacter('u');
            } else {
              // With /u, invalid escapes are not treated as identity escapes.
              return ReportError(RegExpError::kInvalidUnicodeEscape);
            }
            break;
          }
          case 'k':
            // Either an identity escape or a named back-reference.  The two
            // interpretations are mutually exclusive: '\\k' is interpreted as
            // an identity escape for non-Unicode patterns without named
            // capture groups, and as the beginning of a named back-reference
            // in all other cases.
            if (unicode() || HasNamedCaptures()) {
              Advance(2);
              ParseNamedBackReference(builder, state CHECK_FAILED);
              break;
            }
            V8_FALLTHROUGH;
          default:
            Advance();
            // With /u, no identity escapes except for syntax characters
            // are allowed. Otherwise, all identity escapes are allowed.
            if (!unicode() || IsSyntaxCharacterOrSlash(current())) {
              builder->AddCharacter(current());
              Advance();
            } else {
              return ReportError(RegExpError::kInvalidEscape);
            }
            break;
        }
        break;
      case '{': {
        int dummy;
        bool parsed = ParseIntervalQuantifier(&dummy, &dummy CHECK_FAILED);
        if (parsed) return ReportError(RegExpError::kNothingToRepeat);
        V8_FALLTHROUGH;
      }
      case '}':
      case ']':
        if (unicode()) {
          return ReportError(RegExpError::kLoneQuantifierBrackets);
        }
        V8_FALLTHROUGH;
      default:
        builder->AddUnicodeCharacter(current());
        Advance();
        break;
    }  // end switch(current())

    int min;
    int max;
    switch (current()) {
      // QuantifierPrefix ::
      //   *
      //   +
      //   ?
      //   {
      case '*':
        min = 0;
        max = RegExpTree::kInfinity;
        Advance();
        break;
      case '+':
        min = 1;
        max = RegExpTree::kInfinity;
        Advance();
        break;
      case '?':
        min = 0;
        max = 1;
        Advance();
        break;
      case '{':
        if (ParseIntervalQuantifier(&min, &max)) {
          if (max < min) {
            return ReportError(RegExpError::kRangeOutOfOrder);
          }
          break;
        } else if (unicode()) {
          // With /u, incomplete quantifiers are not allowed.
          return ReportError(RegExpError::kIncompleteQuantifier);
        }
        continue;
      default:
        continue;
    }
    RegExpQuantifier::QuantifierType quantifier_type = RegExpQuantifier::GREEDY;
    if (current() == '?') {
      quantifier_type = RegExpQuantifier::NON_GREEDY;
      Advance();
    } else if (FLAG_regexp_possessive_quantifier && current() == '+') {
      // FLAG_regexp_possessive_quantifier is a debug-only flag.
      quantifier_type = RegExpQuantifier::POSSESSIVE;
      Advance();
    }
    if (!builder->AddQuantifierToAtom(min, max, quantifier_type)) {
      return ReportError(RegExpError::kInvalidQuantifier);
    }
  }
}

RegExpParser::RegExpParserState* RegExpParser::ParseOpenParenthesis(
    RegExpParserState* state) {
  RegExpLookaround::Type lookaround_type = state->lookaround_type();
  bool is_named_capture = false;
  JSRegExp::Flags switch_on = JSRegExp::kNone;
  JSRegExp::Flags switch_off = JSRegExp::kNone;
  const ZoneVector<uc16>* capture_name = nullptr;
  SubexpressionType subexpr_type = CAPTURE;
  Advance();
  if (current() == '?') {
    switch (Next()) {
      case ':':
        Advance(2);
        subexpr_type = GROUPING;
        break;
      case '=':
        Advance(2);
        lookaround_type = RegExpLookaround::LOOKAHEAD;
        subexpr_type = POSITIVE_LOOKAROUND;
        break;
      case '!':
        Advance(2);
        lookaround_type = RegExpLookaround::LOOKAHEAD;
        subexpr_type = NEGATIVE_LOOKAROUND;
        break;
      case '-':
      case 'i':
      case 's':
      case 'm': {
        if (!FLAG_regexp_mode_modifiers) {
          ReportError(RegExpError::kInvalidGroup);
          return nullptr;
        }
        Advance();
        bool flags_sense = true;  // Switching on flags.
        while (subexpr_type != GROUPING) {
          switch (current()) {
            case '-':
              if (!flags_sense) {
                ReportError(RegExpError::kMultipleFlagDashes);
                return nullptr;
              }
              flags_sense = false;
              Advance();
              continue;
            case 's':
            case 'i':
            case 'm': {
              JSRegExp::Flags bit = JSRegExp::kUnicode;
              if (current() == 'i') bit = JSRegExp::kIgnoreCase;
              if (current() == 'm') bit = JSRegExp::kMultiline;
              if (current() == 's') bit = JSRegExp::kDotAll;
              if (((switch_on | switch_off) & bit) != 0) {
                ReportError(RegExpError::kRepeatedFlag);
                return nullptr;
              }
              if (flags_sense) {
                switch_on |= bit;
              } else {
                switch_off |= bit;
              }
              Advance();
              continue;
            }
            case ')': {
              Advance();
              state->builder()
                  ->FlushText();  // Flush pending text using old flags.
              // These (?i)-style flag switches don't put us in a subexpression
              // at all, they just modify the flags in the rest of the current
              // subexpression.
              JSRegExp::Flags flags =
                  (state->builder()->flags() | switch_on) & ~switch_off;
              state->builder()->set_flags(flags);
              return state;
            }
            case ':':
              Advance();
              subexpr_type = GROUPING;  // Will break us out of the outer loop.
              continue;
            default:
              ReportError(RegExpError::kInvalidFlagGroup);
              return nullptr;
          }
        }
        break;
      }
      case '<':
        Advance();
        if (Next() == '=') {
          Advance(2);
          lookaround_type = RegExpLookaround::LOOKBEHIND;
          subexpr_type = POSITIVE_LOOKAROUND;
          break;
        } else if (Next() == '!') {
          Advance(2);
          lookaround_type = RegExpLookaround::LOOKBEHIND;
          subexpr_type = NEGATIVE_LOOKAROUND;
          break;
        }
        is_named_capture = true;
        has_named_captures_ = true;
        Advance();
        break;
      default:
        ReportError(RegExpError::kInvalidGroup);
        return nullptr;
    }
  }
  if (subexpr_type == CAPTURE) {
    if (captures_started_ >= JSRegExp::kMaxCaptures) {
      ReportError(RegExpError::kTooManyCaptures);
      return nullptr;
    }
    captures_started_++;

    if (is_named_capture) {
      capture_name = ParseCaptureGroupName(CHECK_FAILED);
    }
  }
  JSRegExp::Flags flags = (state->builder()->flags() | switch_on) & ~switch_off;
  // Store current state and begin new disjunction parsing.
  return zone()->New<RegExpParserState>(state, subexpr_type, lookaround_type,
                                        captures_started_, capture_name, flags,
                                        zone());
}

#ifdef DEBUG
// Currently only used in an DCHECK.
static bool IsSpecialClassEscape(uc32 c) {
  switch (c) {
    case 'd':
    case 'D':
    case 's':
    case 'S':
    case 'w':
    case 'W':
      return true;
    default:
      return false;
  }
}
#endif


// In order to know whether an escape is a backreference or not we have to scan
// the entire regexp and find the number of capturing parentheses.  However we
// don't want to scan the regexp twice unless it is necessary.  This mini-parser
// is called when needed.  It can see the difference between capturing and
// noncapturing parentheses and can skip character classes and backslash-escaped
// characters.
void RegExpParser::ScanForCaptures() {
  DCHECK(!is_scanned_for_captures_);
  const int saved_position = position();
  // Start with captures started previous to current position
  int capture_count = captures_started();
  // Add count of captures after this position.
  int n;
  while ((n = current()) != kEndMarker) {
    Advance();
    switch (n) {
      case '\\\\':
        Advance();
        break;
      case '[': {
        int c;
        while ((c = current()) != kEndMarker) {
          Advance();
          if (c == '\\\\') {
            Advance();
          } else {
            if (c == ']') break;
          }
        }
        break;
      }
      case '(':
        if (current() == '?') {
          // At this point we could be in
          // * a non-capturing group '(:',
          // * a lookbehind assertion '(?<=' '(?<!'
          // * or a named capture '(?<'.
          //
          // Of these, only named captures are capturing groups.

          Advance();
          if (current() != '<') break;

          Advance();
          if (current() == '=' || current() == '!') break;

          // Found a possible named capture. It could turn out to be a syntax
          // error (e.g. an unterminated or invalid name), but that distinction
          // does not matter for our purposes.
          has_named_captures_ = true;
        }
        capture_count++;
        break;
    }
  }
  capture_count_ = capture_count;
  is_scanned_for_captures_ = true;
  Reset(saved_position);
}


bool RegExpParser::ParseBackReferenceIndex(int* index_out) {
  DCHECK_EQ('\\\\', current());
  DCHECK('1' <= Next() && Next() <= '9');
  // Try to parse a decimal literal that is no greater than the total number
  // of left capturing parentheses in the input.
  int start = position();
  int value = Next() - '0';
  Advance(2);
  while (true) {
    uc32 c = current();
    if (IsDecimalDigit(c)) {
      value = 10 * value + (c - '0');
      if (value > JSRegExp::kMaxCaptures) {
        Reset(start);
        return false;
      }
      Advance();
    } else {
      break;
    }
  }
  if (value > captures_started()) {
    if (!is_scanned_for_captures_) ScanForCaptures();
    if (value > capture_count_) {
      Reset(start);
      return false;
    }
  }
  *index_out = value;
  return true;
}

static void push_code_unit(ZoneVector<uc16>* v, uint32_t code_unit) {
  if (code_unit <= unibrow::Utf16::kMaxNonSurrogateCharCode) {
    v->push_back(code_unit);
  } else {
    v->push_back(unibrow::Utf16::LeadSurrogate(code_unit));
    v->push_back(unibrow::Utf16::TrailSurrogate(code_unit));
  }
}

const ZoneVector<uc16>* RegExpParser::ParseCaptureGroupName() {
  ZoneVector<uc16>* name = zone()->New<ZoneVector<uc16>>(zone());

  bool at_start = true;
  while (true) {
    uc32 c = current();
    Advance();

    // Convert unicode escapes.
    if (c == '\\\\' && current() == 'u') {
      Advance();
      if (!ParseUnicodeEscape(&c)) {
        ReportError(RegExpError::kInvalidUnicodeEscape);
        return nullptr;
      }
    }

    // The backslash char is misclassified as both ID_Start and ID_Continue.
    if (c == '\\\\') {
      ReportError(RegExpError::kInvalidCaptureGroupName);
      return nullptr;
    }

    if (at_start) {
      if (!IsIdentifierStart(c)) {
        ReportError(RegExpError::kInvalidCaptureGroupName);
        return nullptr;
      }
      push_code_unit(name, c);
      at_start = false;
    } else {
      if (c == '>') {
        break;
      } else if (IsIdentifierPart(c)) {
        push_code_unit(name, c);
      } else {
        ReportError(RegExpError::kInvalidCaptureGroupName);
        return nullptr;
      }
    }
  }

  return name;
}

bool RegExpParser::CreateNamedCaptureAtIndex(const ZoneVector<uc16>* name,
                                             int index) {
  DCHECK(0 < index && index <= captures_started_);
  DCHECK_NOT_NULL(name);

  RegExpCapture* capture = GetCapture(index);
  DCHECK_NULL(capture->name());

  capture->set_name(name);

  if (named_captures_ == nullptr) {
    named_captures_ =
        zone_->New<ZoneSet<RegExpCapture*, RegExpCaptureNameLess>>(zone());
  } else {
    // Check for duplicates and bail if we find any.

    const auto& named_capture_it = named_captures_->find(capture);
    if (named_capture_it != named_captures_->end()) {
      ReportError(RegExpError::kDuplicateCaptureGroupName);
      return false;
    }
  }

  named_captures_->emplace(capture);

  return true;
}

bool RegExpParser::ParseNamedBackReference(RegExpBuilder* builder,
                                           RegExpParserState* state) {
  // The parser is assumed to be on the '<' in \\k<name>.
  if (current() != '<') {
    ReportError(RegExpError::kInvalidNamedReference);
    return false;
  }

  Advance();
  const ZoneVector<uc16>* name = ParseCaptureGroupName();
  if (name == nullptr) {
    return false;
  }

  if (state->IsInsideCaptureGroup(name)) {
    builder->AddEmpty();
  } else {
    RegExpBackReference* atom =
        zone()->New<RegExpBackReference>(builder->flags());
    atom->set_name(name);

    builder->AddAtom(atom);

    if (named_back_references_ == nullptr) {
      named_back_references_ =
          zone()->New<ZoneList<RegExpBackReference*>>(1, zone());
    }
    named_back_references_->Add(atom, zone());
  }

  return true;
}

void RegExpParser::PatchNamedBackReferences() {
  if (named_back_references_ == nullptr) return;

  if (named_captures_ == nullptr) {
    ReportError(RegExpError::kInvalidNamedCaptureReference);
    return;
  }

  // Look up and patch the actual capture for each named back reference.

  for (int i = 0; i < named_back_references_->length(); i++) {
    RegExpBackReference* ref = named_back_references_->at(i);

    // Capture used to search the named_captures_ by name, index of the
    // capture is never used.
    static const int kInvalidIndex = 0;
    RegExpCapture* search_capture = zone()->New<RegExpCapture>(kInvalidIndex);
    DCHECK_NULL(search_capture->name());
    search_capture->set_name(ref->name());

    int index = -1;
    const auto& capture_it = named_captures_->find(search_capture);
    if (capture_it != named_captures_->end()) {
      index = (*capture_it)->index();
    } else {
      ReportError(RegExpError::kInvalidNamedCaptureReference);
      return;
    }

    ref->set_capture(GetCapture(index));
  }
}

RegExpCapture* RegExpParser::GetCapture(int index) {
  // The index for the capture groups are one-based. Its index in the list is
  // zero-based.
  int know_captures =
      is_scanned_for_captures_ ? capture_count_ : captures_started_;
  DCHECK(index <= know_captures);
  if (captures_ == nullptr) {
    captures_ = zone()->New<ZoneList<RegExpCapture*>>(know_captures, zone());
  }
  while (captures_->length() < know_captures) {
    captures_->Add(zone()->New<RegExpCapture>(captures_->length() + 1), zone());
  }
  return captures_->at(index - 1);
}

namespace {

struct RegExpCaptureIndexLess {
  bool operator()(const RegExpCapture* lhs, const RegExpCapture* rhs) const {
    DCHECK_NOT_NULL(lhs);
    DCHECK_NOT_NULL(rhs);
    return lhs->index() < rhs->index();
  }
};

}  // namespace

Handle<FixedArray> RegExpParser::CreateCaptureNameMap() {
  if (named_captures_ == nullptr || named_captures_->empty()) {
    return Handle<FixedArray>();
  }

  // Named captures are sorted by name (because the set is used to ensure
  // name uniqueness). But the capture name map must to be sorted by index.

  ZoneVector<RegExpCapture*> sorted_named_captures(
      named_captures_->begin(), named_captures_->end(), zone());
  std::sort(sorted_named_captures.begin(), sorted_named_captures.end(),
            RegExpCaptureIndexLess{});
  DCHECK_EQ(sorted_named_captures.size(), named_captures_->size());

  Factory* factory = isolate()->factory();

  int len = static_cast<int>(sorted_named_captures.size()) * 2;
  Handle<FixedArray> array = factory->NewFixedArray(len);

  int i = 0;
  for (const auto& capture : sorted_named_captures) {
    Vector<const uc16> capture_name(capture->name()->data(),
                                    capture->name()->size());
    // CSA code in ConstructNewResultFromMatchInfo requires these strings to be
    // internalized so they can be used as property names in the 'exec' results.
    Handle<String> name = factory->InternalizeString(capture_name);
    array->set(i * 2, *name);
    array->set(i * 2 + 1, Smi::FromInt(capture->index()));

    i++;
  }
  DCHECK_EQ(i * 2, len);

  return array;
}

bool RegExpParser::HasNamedCaptures() {
  if (has_named_captures_ || is_scanned_for_captures_) {
    return has_named_captures_;
  }

  ScanForCaptures();
  DCHECK(is_scanned_for_captures_);
  return has_named_captures_;
}

bool RegExpParser::RegExpParserState::IsInsideCaptureGroup(int index) {
  for (RegExpParserState* s = this; s != nullptr; s = s->previous_state()) {
    if (s->group_type() != CAPTURE) continue;
    // Return true if we found the matching capture index.
    if (index == s->capture_index()) return true;
    // Abort if index is larger than what has been parsed up till this state.
    if (index > s->capture_index()) return false;
  }
  return false;
}

bool RegExpParser::RegExpParserState::IsInsideCaptureGroup(
    const ZoneVector<uc16>* name) {
  DCHECK_NOT_NULL(name);
  for (RegExpParserState* s = this; s != nullptr; s = s->previous_state()) {
    if (s->capture_name() == nullptr) continue;
    if (*s->capture_name() == *name) return true;
  }
  return false;
}

// QuantifierPrefix ::
//   { DecimalDigits }
//   { DecimalDigits , }
//   { DecimalDigits , DecimalDigits }
//
// Returns true if parsing succeeds, and set the min_out and max_out
// values. Values are truncated to RegExpTree::kInfinity if they overflow.
bool RegExpParser::ParseIntervalQuantifier(int* min_out, int* max_out) {
  DCHECK_EQ(current(), '{');
  int start = position();
  Advance();
  int min = 0;
  if (!IsDecimalDigit(current())) {
    Reset(start);
    return false;
  }
  while (IsDecimalDigit(current())) {
    int next = current() - '0';
    if (min > (RegExpTree::kInfinity - next) / 10) {
      // Overflow. Skip past remaining decimal digits and return -1.
      do {
        Advance();
      } while (IsDecimalDigit(current()));
      min = RegExpTree::kInfinity;
      break;
    }
    min = 10 * min + next;
    Advance();
  }
  int max = 0;
  if (current() == '}') {
    max = min;
    Advance();
  } else if (current() == ',') {
    Advance();
    if (current() == '}') {
      max = RegExpTree::kInfinity;
      Advance();
    } else {
      while (IsDecimalDigit(current())) {
        int next = current() - '0';
        if (max > (RegExpTree::kInfinity - next) / 10) {
          do {
            Advance();
          } while (IsDecimalDigit(current()));
          max = RegExpTree::kInfinity;
          break;
        }
        max = 10 * max + next;
        Advance();
      }
      if (current() != '}') {
        Reset(start);
        return false;
      }
      Advance();
    }
  } else {
    Reset(start);
    return false;
  }
  *min_out = min;
  *max_out = max;
  return true;
}


uc32 RegExpParser::ParseOctalLiteral() {
  DCHECK(('0' <= current() && current() <= '7') || current() == kEndMarker);
  // For compatibility with some other browsers (not all), we parse
  // up to three octal digits with a value below 256.
  // ES#prod-annexB-LegacyOctalEscapeSequence
  uc32 value = current() - '0';
  Advance();
  if ('0' <= current() && current() <= '7') {
    value = value * 8 + current() - '0';
    Advance();
    if (value < 32 && '0' <= current() && current() <= '7') {
      value = value * 8 + current() - '0';
      Advance();
    }
  }
  return value;
}


bool RegExpParser::ParseHexEscape(int length, uc32* value) {
  int start = position();
  uc32 val = 0;
  for (int i = 0; i < length; ++i) {
    uc32 c = current();
    int d = HexValue(c);
    if (d < 0) {
      Reset(start);
      return false;
    }
    val = val * 16 + d;
    Advance();
  }
  *value = val;
  return true;
}

// This parses RegExpUnicodeEscapeSequence as described in ECMA262.
bool RegExpParser::ParseUnicodeEscape(uc32* value) {
  // Accept both \\uxxxx and \\u{xxxxxx} (if harmony unicode escapes are
  // allowed). In the latter case, the number of hex digits between { } is
  // arbitrary. \\ and u have already been read.
  if (current() == '{' && unicode()) {
    int start = position();
    Advance();
    if (ParseUnlimitedLengthHexNumber(0x10FFFF, value)) {
      if (current() == '}') {
        Advance();
        return true;
      }
    }
    Reset(start);
    return false;
  }
  // \\u but no {, or \\u{...} escapes not allowed.
  bool result = ParseHexEscape(4, value);
  if (result && unicode() && unibrow::Utf16::IsLeadSurrogate(*value) &&
      current() == '\\\\') {
    // Attempt to read trail surrogate.
    int start = position();
    if (Next() == 'u') {
      Advance(2);
      uc32 trail;
      if (ParseHexEscape(4, &trail) &&
          unibrow::Utf16::IsTrailSurrogate(trail)) {
        *value = unibrow::Utf16::CombineSurrogatePair(static_cast<uc16>(*value),
                                                      static_cast<uc16>(trail));
        return true;
      }
    }
    Reset(start);
  }
  return result;
}

#ifdef V8_INTL_SUPPORT

namespace {

bool IsExactPropertyAlias(const char* property_name, UProperty property) {
  const char* short_name = u_getPropertyName(property, U_SHORT_PROPERTY_NAME);
  if (short_name != nullptr && strcmp(property_name, short_name) == 0)
    return true;
  for (int i = 0;; i++) {
    const char* long_name = u_getPropertyName(
        property, static_cast<UPropertyNameChoice>(U_LONG_PROPERTY_NAME + i));
    if (long_name == nullptr) break;
    if (strcmp(property_name, long_name) == 0) return true;
  }
  return false;
}

bool IsExactPropertyValueAlias(const char* property_value_name,
                               UProperty property, int32_t property_value) {
  const char* short_name =
      u_getPropertyValueName(property, property_value, U_SHORT_PROPERTY_NAME);
  if (short_name != nullptr && strcmp(property_value_name, short_name) == 0) {
    return true;
  }
  for (int i = 0;; i++) {
    const char* long_name = u_getPropertyValueName(
        property, property_value,
        static_cast<UPropertyNameChoice>(U_LONG_PROPERTY_NAME + i));
    if (long_name == nullptr) break;
    if (strcmp(property_value_name, long_name) == 0) return true;
  }
  return false;
}

bool LookupPropertyValueName(UProperty property,
                             const char* property_value_name, bool negate,
                             ZoneList<CharacterRange>* result, Zone* zone) {
  UProperty property_for_lookup = property;
  if (property_for_lookup == UCHAR_SCRIPT_EXTENSIONS) {
    // For the property Script_Extensions, we have to do the property value
    // name lookup as if the property is Script.
    property_for_lookup = UCHAR_SCRIPT;
  }
  int32_t property_value =
      u_getPropertyValueEnum(property_for_lookup, property_value_name);
  if (property_value == UCHAR_INVALID_CODE) return false;

  // We require the property name to match exactly to one of the property value
  // aliases. However, u_getPropertyValueEnum uses loose matching.
  if (!IsExactPropertyValueAlias(property_value_name, property_for_lookup,
                                 property_value)) {
    return false;
  }

  UErrorCode ec = U_ZERO_ERROR;
  icu::UnicodeSet set;
  set.applyIntPropertyValue(property, property_value, ec);
  bool success = ec == U_ZERO_ERROR && !set.isEmpty();

  if (success) {
    set.removeAllStrings();
    if (negate) set.complement();
    for (int i = 0; i < set.getRangeCount(); i++) {
      result->Add(
          CharacterRange::Range(set.getRangeStart(i), set.getRangeEnd(i)),
          zone);
    }
  }
  return success;
}

template <size_t N>
inline bool NameEquals(const char* name, const char (&literal)[N]) {
  return strncmp(name, literal, N + 1) == 0;
}

bool LookupSpecialPropertyValueName(const char* name,
                                    ZoneList<CharacterRange>* result,
                                    bool negate, Zone* zone) {
  if (NameEquals(name, ""Any"")) {
    if (negate) {
      // Leave the list of character ranges empty, since the negation of 'Any'
      // is the empty set.
    } else {
      result->Add(CharacterRange::Everything(), zone);
    }
  } else if (NameEquals(name, ""ASCII"")) {
    result->Add(negate ? CharacterRange::Range(0x80, String::kMaxCodePoint)
                       : CharacterRange::Range(0x0, 0x7F),
                zone);
  } else if (NameEquals(name, ""Assigned"")) {
    return LookupPropertyValueName(UCHAR_GENERAL_CATEGORY, ""Unassigned"",
                                   !negate, result, zone);
  } else {
    return false;
  }
  return true;
}

// Explicitly allowlist supported binary properties. The spec forbids supporting
// properties outside of this set to ensure interoperability.
bool IsSupportedBinaryProperty(UProperty property) {
  switch (property) {
    case UCHAR_ALPHABETIC:
    // 'Any' is not supported by ICU. See LookupSpecialPropertyValueName.
    // 'ASCII' is not supported by ICU. See LookupSpecialPropertyValueName.
    case UCHAR_ASCII_HEX_DIGIT:
    // 'Assigned' is not supported by ICU. See LookupSpecialPropertyValueName.
    case UCHAR_BIDI_CONTROL:
    case UCHAR_BIDI_MIRRORED:
    case UCHAR_CASE_IGNORABLE:
    case UCHAR_CASED:
    case UCHAR_CHANGES_WHEN_CASEFOLDED:
    case UCHAR_CHANGES_WHEN_CASEMAPPED:
    case UCHAR_CHANGES_WHEN_LOWERCASED:
    case UCHAR_CHANGES_WHEN_NFKC_CASEFOLDED:
    case UCHAR_CHANGES_WHEN_TITLECASED:
    case UCHAR_CHANGES_WHEN_UPPERCASED:
    case UCHAR_DASH:
    case UCHAR_DEFAULT_IGNORABLE_CODE_POINT:
    case UCHAR_DEPRECATED:
    case UCHAR_DIACRITIC:
    case UCHAR_EMOJI:
    case UCHAR_EMOJI_COMPONENT:
    case UCHAR_EMOJI_MODIFIER_BASE:
    case UCHAR_EMOJI_MODIFIER:
    case UCHAR_EMOJI_PRESENTATION:
    case UCHAR_EXTENDED_PICTOGRAPHIC:
    case UCHAR_EXTENDER:
    case UCHAR_GRAPHEME_BASE:
    case UCHAR_GRAPHEME_EXTEND:
    case UCHAR_HEX_DIGIT:
    case UCHAR_ID_CONTINUE:
    case UCHAR_ID_START:
    case UCHAR_IDEOGRAPHIC:
    case UCHAR_IDS_BINARY_OPERATOR:
    case UCHAR_IDS_TRINARY_OPERATOR:
    case UCHAR_JOIN_CONTROL:
    case UCHAR_LOGICAL_ORDER_EXCEPTION:
    case UCHAR_LOWERCASE:
    case UCHAR_MATH:
    case UCHAR_NONCHARACTER_CODE_POINT:
    case UCHAR_PATTERN_SYNTAX:
    case UCHAR_PATTERN_WHITE_SPACE:
    case UCHAR_QUOTATION_MARK:
    case UCHAR_RADICAL:
    case UCHAR_REGIONAL_INDICATOR:
    case UCHAR_S_TERM:
    case UCHAR_SOFT_DOTTED:
    case UCHAR_TERMINAL_PUNCTUATION:
    case UCHAR_UNIFIED_IDEOGRAPH:
    case UCHAR_UPPERCASE:
    case UCHAR_VARIATION_SELECTOR:
    case UCHAR_WHITE_SPACE:
    case UCHAR_XID_CONTINUE:
    case UCHAR_XID_START:
      return true;
    default:
      break;
  }
  return false;
}

bool IsUnicodePropertyValueCharacter(char c) {
  // https://tc39.github.io/proposal-regexp-unicode-property-escapes/
  //
  // Note that using this to validate each parsed char is quite conservative.
  // A possible alternative solution would be to only ensure the parsed
  // property name/value candidate string does not contain '\\0' characters and
  // let ICU lookups trigger the final failure.
  if ('a' <= c && c <= 'z') return true;
  if ('A' <= c && c <= 'Z') return true;
  if ('0' <= c && c <= '9') return true;
  return (c == '_');
}

}  // anonymous namespace

bool RegExpParser::ParsePropertyClassName(ZoneVector<char>* name_1,
                                          ZoneVector<char>* name_2) {
  DCHECK(name_1->empty());
  DCHECK(name_2->empty());
  // Parse the property class as follows:
  // - In \\p{name}, 'name' is interpreted
  //   - either as a general category property value name.
  //   - or as a binary property name.
  // - In \\p{name=value}, 'name' is interpreted as an enumerated property name,
  //   and 'value' is interpreted as one of the available property value names.
  // - Aliases in PropertyAlias.txt and PropertyValueAlias.txt can be used.
  // - Loose matching is not applied.
  if (current() == '{') {
    // Parse \\p{[PropertyName=]PropertyNameValue}
    for (Advance(); current() != '}' && current() != '='; Advance()) {
      if (!IsUnicodePropertyValueCharacter(current())) return false;
      if (!has_next()) return false;
      name_1->push_back(static_cast<char>(current()));
    }
    if (current() == '=') {
      for (Advance(); current() != '}'; Advance()) {
        if (!IsUnicodePropertyValueCharacter(current())) return false;
        if (!has_next()) return false;
        name_2->push_back(static_cast<char>(current()));
      }
      name_2->push_back(0);  // null-terminate string.
    }
  } else {
    return false;
  }
  Advance();
  name_1->push_back(0);  // null-terminate string.

  DCHECK(name_1->size() - 1 == std::strlen(name_1->data()));
  DCHECK(name_2->empty() || name_2->size() - 1 == std::strlen(name_2->data()));
  return true;
}

bool RegExpParser::AddPropertyClassRange(ZoneList<CharacterRange>* add_to,
                                         bool negate,
                                         const ZoneVector<char>& name_1,
                                         const ZoneVector<char>& name_2) {
  if (name_2.empty()) {
    // First attempt to interpret as general category property value name.
    const char* name = name_1.data();
    if (LookupPropertyValueName(UCHAR_GENERAL_CATEGORY_MASK, name, negate,
                                add_to, zone())) {
      return true;
    }
    // Interpret ""Any"", ""ASCII"", and ""Assigned"".
    if (LookupSpecialPropertyValueName(name, add_to, negate, zone())) {
      return true;
    }
    // Then attempt to interpret as binary property name with value name 'Y'.
    UProperty property = u_getPropertyEnum(name);
    if (!IsSupportedBinaryProperty(property)) return false;
    if (!IsExactPropertyAlias(name, property)) return false;
    return LookupPropertyValueName(property, negate ? ""N"" : ""Y"", false, add_to,
                                   zone());
  } else {
    // Both property name and value name are specified. Attempt to interpret
    // the property name as enumerated property.
    const char* property_name = name_1.data();
    const char* value_name = name_2.data();
    UProperty property = u_getPropertyEnum(property_name);
    if (!IsExactPropertyAlias(property_name, property)) return false;
    if (property == UCHAR_GENERAL_CATEGORY) {
      // We want to allow aggregate value names such as ""Letter"".
      property = UCHAR_GENERAL_CATEGORY_MASK;
    } else if (property != UCHAR_SCRIPT &&
               property != UCHAR_SCRIPT_EXTENSIONS) {
      return false;
    }
    return LookupPropertyValueName(property, value_name, negate, add_to,
                                   zone());
  }
}

RegExpTree* RegExpParser::GetPropertySequence(const ZoneVector<char>& name_1) {
  if (!FLAG_harmony_regexp_sequence) return nullptr;
  const char* name = name_1.data();
  const uc32* sequence_list = nullptr;
  JSRegExp::Flags flags = JSRegExp::kUnicode;
  if (NameEquals(name, ""Emoji_Flag_Sequence"")) {
    sequence_list = UnicodePropertySequences::kEmojiFlagSequences;
  } else if (NameEquals(name, ""Emoji_Tag_Sequence"")) {
    sequence_list = UnicodePropertySequences::kEmojiTagSequences;
  } else if (NameEquals(name, ""Emoji_ZWJ_Sequence"")) {
    sequence_list = UnicodePropertySequences::kEmojiZWJSequences;
  }
  if (sequence_list != nullptr) {
    // TODO(yangguo): this creates huge regexp code. Alternative to this is
    // to create a new operator that checks for these sequences at runtime.
    RegExpBuilder builder(zone(), flags);
    while (true) {                   // Iterate through list of sequences.
      while (*sequence_list != 0) {  // Iterate through sequence.
        builder.AddUnicodeCharacter(*sequence_list);
        sequence_list++;
      }
      sequence_list++;
      if (*sequence_list == 0) break;
      builder.NewAlternative();
    }
    return builder.ToRegExp();
  }

  if (NameEquals(name, ""Emoji_Keycap_Sequence"")) {
    // https://unicode.org/reports/tr51/#def_emoji_keycap_sequence
    // emoji_keycap_sequence := [0-9#*] \\x{FE0F 20E3}
    RegExpBuilder builder(zone(), flags);
    ZoneList<CharacterRange>* prefix_ranges =
        zone()->New<ZoneList<CharacterRange>>(2, zone());
    prefix_ranges->Add(CharacterRange::Range('0', '9'), zone());
    prefix_ranges->Add(CharacterRange::Singleton('#'), zone());
    prefix_ranges->Add(CharacterRange::Singleton('*'), zone());
    builder.AddCharacterClass(
        zone()->New<RegExpCharacterClass>(zone(), prefix_ranges, flags));
    builder.AddCharacter(0xFE0F);
    builder.AddCharacter(0x20E3);
    return builder.ToRegExp();
  } else if (NameEquals(name, ""Emoji_Modifier_Sequence"")) {
    // https://unicode.org/reports/tr51/#def_emoji_modifier_sequence
    // emoji_modifier_sequence := emoji_modifier_base emoji_modifier
    RegExpBuilder builder(zone(), flags);
    ZoneList<CharacterRange>* modifier_base_ranges =
        zone()->New<ZoneList<CharacterRange>>(2, zone());
    LookupPropertyValueName(UCHAR_EMOJI_MODIFIER_BASE, ""Y"", false,
                            modifier_base_ranges, zone());
    builder.AddCharacterClass(
        zone()->New<RegExpCharacterClass>(zone(), modifier_base_ranges, flags));
    ZoneList<CharacterRange>* modifier_ranges =
        zone()->New<ZoneList<CharacterRange>>(2, zone());
    LookupPropertyValueName(UCHAR_EMOJI_MODIFIER, ""Y"", false, modifier_ranges,
                            zone());
    builder.AddCharacterClass(
        zone()->New<RegExpCharacterClass>(zone(), modifier_ranges, flags));
    return builder.ToRegExp();
  }

  return nullptr;
}

#else  // V8_INTL_SUPPORT

bool RegExpParser::ParsePropertyClassName(ZoneVector<char>* name_1,
                                          ZoneVector<char>* name_2) {
  return false;
}

bool RegExpParser::AddPropertyClassRange(ZoneList<CharacterRange>* add_to,
                                         bool negate,
                                         const ZoneVector<char>& name_1,
                                         const ZoneVector<char>& name_2) {
  return false;
}

RegExpTree* RegExpParser::GetPropertySequence(const ZoneVector<char>& name) {
  return nullptr;
}

#endif  // V8_INTL_SUPPORT

bool RegExpParser::ParseUnlimitedLengthHexNumber(int max_value, uc32* value) {
  uc32 x = 0;
  int d = HexValue(current());
  if (d < 0) {
    return false;
  }
  while (d >= 0) {
    x = x * 16 + d;
    if (x > static_cast<uc32>(max_value)) {
      return false;
    }
    Advance();
    d = HexValue(current());
  }
  *value = x;
  return true;
}


uc32 RegExpParser::ParseClassCharacterEscape() {
  DCHECK_EQ('\\\\', current());
  DCHECK(has_next() && !IsSpecialClassEscape(Next()));
  Advance();
  switch (current()) {
    case 'b':
      Advance();
      return '\\b';
    // ControlEscape :: one of
    //   f n r t v
    case 'f':
      Advance();
      return '\\f';
    case 'n':
      Advance();
      return '\\n';
    case 'r':
      Advance();
      return '\\r';
    case 't':
      Advance();
      return '\\t';
    case 'v':
      Advance();
      return '\\v';
    case 'c': {
      uc32 controlLetter = Next();
      uc32 letter = controlLetter & ~('A' ^ 'a');
      // Inside a character class, we also accept digits and underscore as
      // control characters, unless with /u. See Annex B:
      // ES#prod-annexB-ClassControlLetter
      if (letter >= 'A' && letter <= 'Z') {
        Advance(2);
        // Control letters mapped to ASCII control characters in the range
        // 0x00-0x1F.
        return controlLetter & 0x1F;
      }
      if (unicode()) {
        // With /u, invalid escapes are not treated as identity escapes.
        ReportError(RegExpError::kInvalidClassEscape);
        return 0;
      }
      if ((controlLetter >= '0' && controlLetter <= '9') ||
          controlLetter == '_') {
        Advance(2);
        return controlLetter & 0x1F;
      }
      // We match JSC in reading the backslash as a literal
      // character instead of as starting an escape.
      // TODO(v8:6201): Not yet covered by the spec.
      return '\\\\';
    }
    case '0':
      // With /u, \\0 is interpreted as NUL if not followed by another digit.
      if (unicode() && !(Next() >= '0' && Next() <= '9')) {
        Advance();
        return 0;
      }
      V8_FALLTHROUGH;
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
      // For compatibility, we interpret a decimal escape that isn't
      // a back reference (and therefore either \\0 or not valid according
      // to the specification) as a 1..3 digit octal character code.
      // ES#prod-annexB-LegacyOctalEscapeSequence
      if (unicode()) {
        // With /u, decimal escape is not interpreted as octal character code.
        ReportError(RegExpError::kInvalidClassEscape);
        return 0;
      }
      return ParseOctalLiteral();
    case 'x': {
      Advance();
      uc32 value;
      if (ParseHexEscape(2, &value)) return value;
      if (unicode()) {
        // With /u, invalid escapes are not treated as identity escapes.
        ReportError(RegExpError::kInvalidEscape);
        return 0;
      }
      // If \\x is not followed by a two-digit hexadecimal, treat it
      // as an identity escape.
      return 'x';
    }
    case 'u': {
      Advance();
      uc32 value;
      if (ParseUnicodeEscape(&value)) return value;
      if (unicode()) {
        // With /u, invalid escapes are not treated as identity escapes.
        ReportError(RegExpError::kInvalidUnicodeEscape);
        return 0;
      }
      // If \\u is not followed by a two-digit hexadecimal, treat it
      // as an identity escape.
      return 'u';
    }
    default: {
      uc32 result = current();
      // With /u, no identity escapes except for syntax characters and '-' are
      // allowed. Otherwise, all identity escapes are allowed.
      if (!unicode() || IsSyntaxCharacterOrSlash(result) || result == '-') {
        Advance();
        return result;
      }
      ReportError(RegExpError::kInvalidEscape);
      return 0;
    }
  }
  UNREACHABLE();
}

void RegExpParser::ParseClassEscape(ZoneList<CharacterRange>* ranges,
                                    Zone* zone,
                                    bool add_unicode_case_equivalents,
                                    uc32* char_out, bool* is_class_escape) {
  uc32 current_char = current();
  if (current_char == '\\\\') {
    switch (Next()) {
      case 'w':
      case 'W':
      case 'd':
      case 'D':
      case 's':
      case 'S': {
        CharacterRange::AddClassEscape(static_cast<char>(Next()), ranges,
                                       add_unicode_case_equivalents, zone);
        Advance(2);
        *is_class_escape = true;
        return;
      }
      case kEndMarker:
        ReportError(RegExpError::kEscapeAtEndOfPattern);
        return;
      case 'p':
      case 'P':
        if (unicode()) {
          bool negate = Next() == 'P';
          Advance(2);
          ZoneVector<char> name_1(zone);
          ZoneVector<char> name_2(zone);
          if (!ParsePropertyClassName(&name_1, &name_2) ||
              !AddPropertyClassRange(ranges, negate, name_1, name_2)) {
            ReportError(RegExpError::kInvalidClassPropertyName);
          }
          *is_class_escape = true;
          return;
        }
        break;
      default:
        break;
    }
    *char_out = ParseClassCharacterEscape();
    *is_class_escape = false;
  } else {
    Advance();
    *char_out = current_char;
    *is_class_escape = false;
  }
}

RegExpTree* RegExpParser::ParseCharacterClass(const RegExpBuilder* builder) {
  DCHECK_EQ(current(), '[');
  Advance();
  bool is_negated = false;
  if (current() == '^') {
    is_negated = true;
    Advance();
  }
  ZoneList<CharacterRange>* ranges =
      zone()->New<ZoneList<CharacterRange>>(2, zone());
  bool add_unicode_case_equivalents = unicode() && builder->ignore_case();
  while (has_more() && current() != ']') {
    uc32 char_1, char_2;
    bool is_class_1, is_class_2;
    ParseClassEscape(ranges, zone(), add_unicode_case_equivalents, &char_1,
                     &is_class_1 CHECK_FAILED);
    if (current() == '-') {
      Advance();
      if (current() == kEndMarker) {
        // If we reach the end we break out of the loop and let the
        // following code report an error.
        break;
      } else if (current() == ']') {
        if (!is_class_1) ranges->Add(CharacterRange::Singleton(char_1), zone());
        ranges->Add(CharacterRange::Singleton('-'), zone());
        break;
      }
      ParseClassEscape(ranges, zone(), add_unicode_case_equivalents, &char_2,
                       &is_class_2 CHECK_FAILED);
      if (is_class_1 || is_class_2) {
        // Either end is an escaped character class. Treat the '-' verbatim.
        if (unicode()) {
          // ES2015 21.2.2.15.1 step 1.
          return ReportError(RegExpError::kInvalidCharacterClass);
        }
        if (!is_class_1) ranges->Add(CharacterRange::Singleton(char_1), zone());
        ranges->Add(CharacterRange::Singleton('-'), zone());
        if (!is_class_2) ranges->Add(CharacterRange::Singleton(char_2), zone());
        continue;
      }
      // ES2015 21.2.2.15.1 step 6.
      if (char_1 > char_2) {
        return ReportError(RegExpError::kOutOfOrderCharacterClass);
      }
      ranges->Add(CharacterRange::Range(char_1, char_2), zone());
    } else {
      if (!is_class_1) ranges->Add(CharacterRange::Singleton(char_1), zone());
    }
  }
  if (!has_more()) {
    return ReportError(RegExpError::kUnterminatedCharacterClass);
  }
  Advance();
  RegExpCharacterClass::CharacterClassFlags character_class_flags;
  if (is_negated) character_class_flags = RegExpCharacterClass::NEGATED;
  return zone()->New<RegExpCharacterClass>(zone(), ranges, builder->flags(),
                                           character_class_flags);
}


#undef CHECK_FAILED

bool RegExpParser::Parse(RegExpCompileData* result,
                         const DisallowHeapAllocation&) {
  DCHECK(result != nullptr);
  RegExpTree* tree = ParsePattern();
  if (failed()) {
    DCHECK(tree == nullptr);
    DCHECK(error_ != RegExpError::kNone);
    result->error = error_;
    result->error_pos = error_pos_;
  } else {
    DCHECK(tree != nullptr);
    DCHECK(error_ == RegExpError::kNone);
    if (FLAG_trace_regexp_parser) {
      StdoutStream os;
      tree->Print(os, zone());
      os << ""\\n"";
    }
    result->tree = tree;
    int capture_count = captures_started();
    result->simple = tree->IsAtom() && simple() && capture_count == 0;
    result->contains_anchor = contains_anchor();
    result->capture_count = capture_count;
  }
  return !failed();
}

bool RegExpParser::ParseRegExp(Isolate* isolate, Zone* zone,
                               FlatStringReader* input, JSRegExp::Flags flags,
                               RegExpCompileData* result) {
  RegExpParser parser(input, flags, isolate, zone);
  bool success;
  {
    DisallowHeapAllocation no_gc;
    success = parser.Parse(result, no_gc);
  }
  if (success) {
    result->capture_name_map = parser.CreateCaptureNameMap();
  }
  return success;
}

RegExpBuilder::RegExpBuilder(Zone* zone, JSRegExp::Flags flags)
    : zone_(zone),
      pending_empty_(false),
      flags_(flags),
      characters_(nullptr),
      pending_surrogate_(kNoPendingSurrogate),
      terms_(),
      alternatives_()
#ifdef DEBUG
      ,
      last_added_(ADD_NONE)
#endif
{
}


void RegExpBuilder::AddLeadSurrogate(uc16 lead_surrogate) {
  DCHECK(unibrow::Utf16::IsLeadSurrogate(lead_surrogate));
  FlushPendingSurrogate();
  // Hold onto the lead surrogate, waiting for a trail surrogate to follow.
  pending_surrogate_ = lead_surrogate;
}


void RegExpBuilder::AddTrailSurrogate(uc16 trail_surrogate) {
  DCHECK(unibrow::Utf16::IsTrailSurrogate(trail_surrogate));
  if (pending_surrogate_ != kNoPendingSurrogate) {
    uc16 lead_surrogate = pending_surrogate_;
    pending_surrogate_ = kNoPendingSurrogate;
    DCHECK(unibrow::Utf16::IsLeadSurrogate(lead_surrogate));
    uc32 combined =
        unibrow::Utf16::CombineSurrogatePair(lead_surrogate, trail_surrogate);
    if (NeedsDesugaringForIgnoreCase(combined)) {
      AddCharacterClassForDesugaring(combined);
    } else {
      ZoneList<uc16> surrogate_pair(2, zone());
      surrogate_pair.Add(lead_surrogate, zone());
      surrogate_pair.Add(trail_surrogate, zone());
      RegExpAtom* atom =
          zone()->New<RegExpAtom>(surrogate_pair.ToConstVector(), flags_);
      AddAtom(atom);
    }
  } else {
    pending_surrogate_ = trail_surrogate;
    FlushPendingSurrogate();
  }
}


void RegExpBuilder::FlushPendingSurrogate() {
  if (pending_surrogate_ != kNoPendingSurrogate) {
    DCHECK(unicode());
    uc32 c = pending_surrogate_;
    pending_surrogate_ = kNoPendingSurrogate;
    AddCharacterClassForDesugaring(c);
  }
}


void RegExpBuilder::FlushCharacters() {
  FlushPendingSurrogate();
  pending_empty_ = false;
  if (characters_ != nullptr) {
    RegExpTree* atom =
        zone()->New<RegExpAtom>(characters_->ToConstVector(), flags_);
    characters_ = nullptr;
    text_.Add(atom, zone());
    LAST(ADD_ATOM);
  }
}


void RegExpBuilder::FlushText() {
  FlushCharacters();
  int num_text = text_.length();
  if (num_text == 0) {
    return;
  } else if (num_text == 1) {
    terms_.Add(text_.last(), zone());
  } else {
    RegExpText* text = zone()->New<RegExpText>(zone());
    for (int i = 0; i < num_text; i++) text_.Get(i)->AppendToText(text, zone());
    terms_.Add(text, zone());
  }
  text_.Clear();
}


void RegExpBuilder::AddCharacter(uc16 c) {
  FlushPendingSurrogate();
  pending_empty_ = false;
  if (NeedsDesugaringForIgnoreCase(c)) {
    AddCharacterClassForDesugaring(c);
  } else {
    if (characters_ == nullptr) {
      characters_ = zone()->New<ZoneList<uc16>>(4, zone());
    }
    characters_->Add(c, zone());
    LAST(ADD_CHAR);
  }
}


void RegExpBuilder::AddUnicodeCharacter(uc32 c) {
  if (c > static_cast<uc32>(unibrow::Utf16::kMaxNonSurrogateCharCode)) {
    DCHECK(unicode());
    AddLeadSurrogate(unibrow::Utf16::LeadSurrogate(c));
    AddTrailSurrogate(unibrow::Utf16::TrailSurrogate(c));
  } else if (unicode() && unibrow::Utf16::IsLeadSurrogate(c)) {
    AddLeadSurrogate(c);
  } else if (unicode() && unibrow::Utf16::IsTrailSurrogate(c)) {
    AddTrailSurrogate(c);
  } else {
    AddCharacter(static_cast<uc16>(c));
  }
}

void RegExpBuilder::AddEscapedUnicodeCharacter(uc32 character) {
  // A lead or trail surrogate parsed via escape sequence will not
  // pair up with any preceding lead or following trail surrogate.
  FlushPendingSurrogate();
  AddUnicodeCharacter(character);
  FlushPendingSurrogate();
}

void RegExpBuilder::AddEmpty() { pending_empty_ = true; }


void RegExpBuilder::AddCharacterClass(RegExpCharacterClass* cc) {
  if (NeedsDesugaringForUnicode(cc)) {
    // With /u, character class needs to be desugared, so it
    // must be a standalone term instead of being part of a RegExpText.
    AddTerm(cc);
  } else {
    AddAtom(cc);
  }
}

void RegExpBuilder::AddCharacterClassForDesugaring(uc32 c) {
  AddTerm(zone()->New<RegExpCharacterClass>(
      zone(), CharacterRange::List(zone(), CharacterRange::Singleton(c)),
      flags_));
}


void RegExpBuilder::AddAtom(RegExpTree* term) {
  if (term->IsEmpty()) {
    AddEmpty();
    return;
  }
  if (term->IsTextElement()) {
    FlushCharacters();
    text_.Add(term, zone());
  } else {
    FlushText();
    terms_.Add(term, zone());
  }
  LAST(ADD_ATOM);
}


void RegExpBuilder::AddTerm(RegExpTree* term) {
  FlushText();
  terms_.Add(term, zone());
  LAST(ADD_ATOM);
}


void RegExpBuilder::AddAssertion(RegExpTree* assert) {
  FlushText();
  terms_.Add(assert, zone());
  LAST(ADD_ASSERT);
}


void RegExpBuilder::NewAlternative() { FlushTerms(); }


void RegExpBuilder::FlushTerms() {
  FlushText();
  int num_terms = terms_.length();
  RegExpTree* alternative;
  if (num_terms == 0) {
    alternative = zone()->New<RegExpEmpty>();
  } else if (num_terms == 1) {
    alternative = terms_.last();
  } else {
    alternative = zone()->New<RegExpAlternative>(terms_.GetList(zone()));
  }
  alternatives_.Add(alternative, zone());
  terms_.Clear();
  LAST(ADD_NONE);
}


bool RegExpBuilder::NeedsDesugaringForUnicode(RegExpCharacterClass* cc) {
  if (!unicode()) return false;
  // TODO(yangguo): we could be smarter than this. Case-insensitivity does not
  // necessarily mean that we need to desugar. It's probably nicer to have a
  // separate pass to figure out unicode desugarings.
  if (ignore_case()) return true;
  ZoneList<CharacterRange>* ranges = cc->ranges(zone());
  CharacterRange::Canonicalize(ranges);
  for (int i = ranges->length() - 1; i >= 0; i--) {
    uc32 from = ranges->at(i).from();
    uc32 to = ranges->at(i).to();
    // Check for non-BMP characters.
    if (to >= kNonBmpStart) return true;
    // Check for lone surrogates.
    if (from <= kTrailSurrogateEnd && to >= kLeadSurrogateStart) return true;
  }
  return false;
}


bool RegExpBuilder::NeedsDesugaringForIgnoreCase(uc32 c) {
#ifdef V8_INTL_SUPPORT
  if (unicode() && ignore_case()) {
    icu::UnicodeSet set(c, c);
    set.closeOver(USET_CASE_INSENSITIVE);
    set.removeAllStrings();
    return set.size() > 1;
  }
  // In the case where ICU is not included, we act as if the unicode flag is
  // not set, and do not desugar.
#endif  // V8_INTL_SUPPORT
  return false;
}


RegExpTree* RegExpBuilder::ToRegExp() {
  FlushTerms();
  int num_alternatives = alternatives_.length();
  if (num_alternatives == 0) return zone()->New<RegExpEmpty>();
  if (num_alternatives == 1) return alternatives_.last();
  return zone()->New<RegExpDisjunction>(alternatives_.GetList(zone()));
}

bool RegExpBuilder::AddQuantifierToAtom(
    int min, int max, RegExpQuantifier::QuantifierType quantifier_type) {
  FlushPendingSurrogate();
  if (pending_empty_) {
    pending_empty_ = false;
    return true;
  }
  RegExpTree* atom;
  if (characters_ != nullptr) {
    DCHECK(last_added_ == ADD_CHAR);
    // Last atom was character.
    Vector<const uc16> char_vector = characters_->ToConstVector();
    int num_chars = char_vector.length();
    if (num_chars > 1) {
      Vector<const uc16> prefix = char_vector.SubVector(0, num_chars - 1);
      text_.Add(zone()->New<RegExpAtom>(prefix, flags_), zone());
      char_vector = char_vector.SubVector(num_chars - 1, num_chars);
    }
    characters_ = nullptr;
    atom = zone()->New<RegExpAtom>(char_vector, flags_);
    FlushText();
  } else if (text_.length() > 0) {
    DCHECK(last_added_ == ADD_ATOM);
    atom = text_.RemoveLast();
    FlushText();
  } else if (terms_.length() > 0) {
    DCHECK(last_added_ == ADD_ATOM);
    atom = terms_.RemoveLast();
    if (atom->IsLookaround()) {
      // With /u, lookarounds are not quantifiable.
      if (unicode()) return false;
      // Lookbehinds are not quantifiable.
      if (atom->AsLookaround()->type() == RegExpLookaround::LOOKBEHIND) {
        return false;
      }
    }
    if (atom->max_match() == 0) {
      // Guaranteed to only match an empty string.
      LAST(ADD_TERM);
      if (min == 0) {
        return true;
      }
      terms_.Add(atom, zone());
      return true;
    }
  } else {
    // Only call immediately after adding an atom or character!
    UNREACHABLE();
  }
  terms_.Add(zone()->New<RegExpQuantifier>(min, max, quantifier_type, atom),
             zone());
  LAST(ADD_TERM);
  return true;
}

}  // namespace internal
}  // namespace v8
",16235,True,2869.526425641164,median
"[[verifying-dependencies]]
= Verifying dependencies

Working with external dependencies and plugins published on third-party repositories puts your build at risk.
In particular, you need to be aware of what binaries are brought in transitively and if they are legit.
To mitigate the security risks and avoid integrating compromised dependencies in your project, Gradle supports _dependency verification_.

[IMPORTANT]
====
Dependency verification is, by nature, an inconvenient feature to use.
It means that whenever you're going to update a dependency, builds are likely to fail.
It means that merging branches are going to be harder because each branch can have different dependencies.
It means that you will be tempted to switch it off.

So why should you bother?

Dependency verification is about **trust** in what you get and what you ship.

Without dependency verification it's easy for an attacker to compromise your supply chain.
There are many real world examples of tools compromised by adding a malicious dependency.
Dependency verification is meant to protect yourself from those attacks, by forcing you to ensure that the artifacts you include in your build are the ones that you expect.
It is not meant, however, to prevent you from including _vulnerable_ dependencies.

Finding the right balance between security and convenience is hard but Gradle will try to let you choose the ""right level"" for you.
====

Dependency verification consists of two different and complementary operations:

- _checksum verification_, which allows asserting the integrity of a dependency
- _signature verification_, which allows asserting the provenance of a dependency

Gradle supports both checksum and signature verification out of the box but performs no dependency verification by default.
This section will guide you into configuring dependency verification properly for your needs.

This feature can be used for:

- detecting compromised dependencies
- detecting compromised plugins
- detecting tampered dependencies in the local dependency caches

[[sub:enabling-verification]]
== Enabling dependency verification

[[sub:verification-metadata]]
=== The verification metadata file

[NOTE]
====
Currently the only source of dependency verification metadata is this XML configuration file.
Future versions of Gradle may include other sources (for example via external services).
====

Dependency verification is automatically enabled once the configuration file for dependency verification is discovered.
This configuration file is located at `$PROJECT_ROOT/gradle/verification-metadata.xml`.
This file minimally consists of the following:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <verify-metadata>true</verify-metadata>
      <verify-signatures>false</verify-signatures>
    </configuration>
</verification-metadata>
----

Doing so, Gradle will verify all artifacts using <<#sec:checksum-verification,checksums>>, but will not verify <<#sec:signature-verification,signatures>>.
Gradle will verify any artifact downloaded using its dependency management engine, which includes, but is not limited to:

- artifact files (e.g jar files, zips, ...) used during a build
- metadata artifacts (POM files, Ivy descriptors, Gradle Module Metadata)
- plugins (both project and settings plugins)
- artifacts resolved using the advanced dependency resolution APIs

Gradle will _not_ verify changing dependencies (in particular `SNAPSHOT` dependencies) nor locally produced artifacts (typically jars produced during the build itself) as by nature their checksums and signatures would always change.

With such a minimal configuration file, a project using _any_ external dependency or plugin would immediately start failing because it doesn't contain any checksum to verify.

[[sec:verification-scope]]
=== Scope of the dependency verification

A dependency verification configuration is _global_: a single file is used to configure verification of the whole build.
In particular, the same file is used for both the (sub)projects and `buildSrc`.

If an included build is used:

- the configuration file of the _current_ build is used for verification
- so if the included build itself uses verification, its configuration is ignored in favor of the current one
- which means that including a build works similarly to upgrading a dependency: it may require you to update your current verification metadata

An easy way to get started is therefore to generate the minimal configuration for an existing build.

[[sec:verification-console-output]]
=== Configuring the console output

By default, if dependency verification fails, Gradle will generate a small summary about the verification failure as well as an HTML report containing the full information about the failures.
If your environment prevents you from reading this HTML report file (for example if you run a build on CI and that it's not easy to fetch the remote artifacts), Gradle provides a way to opt-in a verbose console report.
For this, you need to add this Gradle property to your `gradle.properties` file:

----
org.gradle.dependency.verification.console=verbose
----

[[sec:bootstrapping-verification]]
=== Bootstrapping dependency verification

It's worth mentioning that while Gradle can generate a dependency verification file for you, you should always check whatever Gradle generated for you because your build may _already_ contain compromised dependencies without you knowing about it.
Please refer to the appropriate <<#sec:checksum-verification,checksum verification>> or <<#sec:signature-verification,signature verification>> section for more information.

If you plan on using <<#sec:signature-verification,signature verification>>, please also read the <<sec:bootstrapping-signature-verification,corresponding section>> of the docs.

Bootstrapping can either be used to create a file from the beginning, or also to _update_ an existing file with new information.
Therefore, it's recommended to always use the same parameters once you started bootstrapping.

The dependency verification file can be generated with the following CLI instructions:


----
gradle --write-verification-metadata sha256 help
----

The `write-verification-metadata` flag requires the list of <<#sec:checksum-verification,checksums>> that you want to generate or `pgp` for <<#sec:signature-verification,signatures>>.

Executing this command line will cause Gradle to:

* resolve all <<declaring_dependencies.adoc#sec:resolvable-consumable-configs,resolvable configurations>>, which includes:
** configurations from the root project
** configurations from all subprojects
** configurations from `buildSrc`
** included builds configurations
** configurations used by plugins
* download all artifacts discovered during resolution
* compute the requested checksums and possibly verify signatures depending on what you asked
* At the end of the build, generate the configuration file which will contain the inferred _verification metadata_

As a consequence, the `verification-metadata.xml` file will be used in subsequent builds to verify dependencies.

[WARNING]
====
There are dependencies that Gradle _cannot_ discover this way.
In particular, you will notice that the CLI above uses the `help` task.
If you don't specify any task, Gradle will automatically run the default task and generate a configuration file at the end of the build too.

The difference is that Gradle _may_ discover more dependencies and artifacts depending on the tasks you execute.
As a matter of fact, Gradle cannot automatically discover _detached configurations_, which are basically dependency graphs resolved as an internal implementation detail of the execution of a task: they are not, in particular, declared as an input of the task because they effectively depend on the configuration of the task at execution time.

A good way to start is just to use the simplest task, `help`, which will discover as much as possible, and if subsequent builds fail with a verification error, you can re-execute generation with the appropriate tasks to ""discover"" more dependencies.

Gradle won't verify either checksums or signatures of plugins which use their own HTTP clients.
Only plugins which use the infrastructure provided by Gradle for performing requests will see their requests verified.
====

[[sec:verification-update]]
=== Using generation for incremental updates

The verification file generated by Gradle has a strict ordering for all its content.
It also uses the information from the existing state to limit changes to the strict minimum.

This means that generation is actually a convenient tool for _updating_ a verification file:
* Checksum entries generated by Gradle will have a clear `origin` that starts with ""Generated by Gradle"", which is a good indicator that an entry needs to be reviewed,
* Entries added by hand will immediately be accounted for, and appear at the right location after writing the file,
* The header comments of the file will be preserved, i.e. comments before the root XML node.
This allows you to have a license header or instructions on which tasks and which parameters to use for generating that file.

With the above benefits, it is really easy to account for new dependencies or dependency versions by simply generating the file again and reviewing the changes.

[[sec:verification-dry-mode]]
=== Using dry mode

By default, bootstrapping is incremental, which means that if you run it multiple times, information is _added_ to the file and in particular you can rely on your VCS to check the diffs.
There are situations where you would just want to _see_ what the generated verification metadata file would look like without actually changing the existing one or overwriting it.

For this purpose, you can just add `--dry-run`:


----
gradle --write-verification-metadata sha256 help --dry-run
----

Then instead of generating the `verification-metadata.xml` file, a _new file_ will be generated, called `verification-metadata.dryrun.xml`.

[NOTE]
====
Because `--dry-run` doesn't execute tasks, this would be much faster, but it will miss any resolution happening at task execution time.
====

[[sec:disabling-metadata-verification]]
=== Disabling metadata verification

By default, Gradle will not only verify artifacts (jars, ...) but also the metadata associated with those artifacts (typically POM files).
Verifying this ensures the maximum level of security: metadata files typically tell what transitive dependencies will be included, so a compromised metadata file may cause the introduction of undesired dependencies in the graph.
However, because all artifacts are verified, such artifacts would in general easily be discovered by you, because they would cause a checksum verification failure (checksums would be _missing_ from verification metadata).
Because metadata verification can significantly increase the size of your configuration file, you may therefore want to disable verification of metadata.
If you understand the risks of doing so, set the `<verify-metadata>` flag to `false` in the configuration file:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <verify-metadata>false</verify-metadata>
      <verify-signatures>false</verify-signatures>
    </configuration>
    <!-- the rest of this file doesn't need to declare anything about metadata files -->
</verification-metadata>
----

[[sec:checksum-verification]]
== Verifying dependency checksums

Checksum verification allows you to ensure the integrity of an artifact.
This is the simplest thing that Gradle can do for you to make sure that the artifacts you use are un-tampered.

Gradle supports MD5, SHA1, SHA-256 and SHA-512 checksums.
However, only SHA-256 and SHA-512 checksums are considered secure nowadays.

=== Adding the checksum for an artifact

External components are identified by GAV coordinates, then each of the artifacts by their file names.
To declare the checksums of an artifact, you need to add the corresponding section in the verification metadata file.
For example, to declare the checksum for https://pdfbox.apache.org[Apache PDFBox].
The GAV coordinates are:

- group `org.apache.pdfbox`
- name `pdfbox`
- version `2.0.17`

Using this dependency will trigger the download of 2 different files:

- `pdfbox-2.0.17.jar` which is the main artifact
- `pdfbox-2.0.17.pom` which is the metadata file associated with this artifact

As as consequence, you need to declare the checksums for both of them (unless you <<sec:disabling-metadata-verification,disabled metadata verification>>):

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <verify-metadata>true</verify-metadata>
      <verify-signatures>false</verify-signatures>
   </configuration>
   <components>
      <component group=""org.apache.pdfbox"" name=""pdfbox"" version=""2.0.17"">
         <artifact name=""pdfbox-2.0.17.jar"">
            <sha512 value=""7e11e54a21c395d461e59552e88b0de0ebaf1bf9d9bcacadf17b240d9bbc29bf6beb8e36896c186fe405d287f5d517b02c89381aa0fcc5e0aa5814e44f0ab331"" origin=""PDFBox Official site (https://pdfbox.apache.org/download.cgi)""/>
         </artifact>
         <artifact name=""pdfbox-2.0.17.pom"">
            <sha512 value=""82de436b38faf6121d8d2e71dda06e79296fc0f7bc7aba0766728c8d306fd1b0684b5379c18808ca724bf91707277eba81eb4fe19518e99e8f2a56459b79742f"" origin=""Generated by Gradle""/>
         </artifact>
      </component>
   </components>
</verification-metadata>
----

=== Where to get checksums from?

In general, checksums are published alongside artifacts on public repositories.
However, if a dependency is compromised in a repository, it's likely its checksum will be too, so it's a good practice to get the checksum from a different place, usually the website of the library itself.

In fact, it's a good security practice to publish the checksums of artifacts on a _different server_ than the server where the artifacts themselves are hosted: it's harder to compromise a library both on the repository __and__ the official website.

In the example above, the checksum was published on the website for the JAR, but not the POM file.
This is why it's usually easier to <<sec:bootstrapping-verification,let Gradle generate the checksums>> and verify by reviewing the generated file carefully.

// Be explicit about where origin info lives, it's not visible without scrolling right
In this example, not only could we check that the checksum was correct, but we could also find it on the official website, which is why we changed the value of the of `origin` attribute on the `sha512` element from `Generated by Gradle` to `PDFBox Official site`.
Changing the `origin` gives users a sense of how trustworthy your build it.

Interestingly, using `pdfbox` will require _much more_ than those 2 artifacts, because it will also bring in transitive dependencies.
If the dependency verification file only included the checksums for the main artifacts you used, the build would fail with an error like this one:


----
Execution failed for task ':compileJava'.
> Dependency verification failed for configuration ':compileClasspath':
    - On artifact commons-logging-1.2.jar (commons-logging:commons-logging:1.2) in repository 'MavenRepo': checksum is missing from verification metadata.
    - On artifact commons-logging-1.2.pom (commons-logging:commons-logging:1.2) in repository 'MavenRepo': checksum is missing from verification metadata.
----

What this indicates is that your build requires `commons-logging` when executing `compileJava`, however the verification file doesn't contain enough information for Gradle to verify the integrity of the dependencies, meaning you need to add the required information to the verification metadata file.

See <<sec:troubleshooting-verification,troubleshooting dependency verification>> for more insights on what to do in this situation.

=== What checksums are verified?

If a dependency verification metadata file declares more than one checksum for a dependency, Gradle will verify _all of them_ and fail if _any of them fails_.
For example, the following configuration would check both the `md5` and `sha1` checksums:

[source,xml]
----
<component group=""org.apache.pdfbox"" name=""pdfbox"" version=""2.0.17"">
   <artifact name=""pdfbox-2.0.17.jar"">
      <md5 value=""c713a8e252d0add65e9282b151adf6b4"" origin=""official site""/>
      <sha1 value=""b5c8dff799bd967c70ccae75e6972327ae640d35"" origin=""official site""/>
   </artifact>
</component>
----

There are multiple reasons why you'd like to do so:

1. an official site doesn't publish _secure_ checksums (SHA-256, SHA-512) but publishes multiple insecure ones (MD5, SHA1). While it's easy to fake a MD5 checksum and hard but possible to fake a SHA1 checksum, it's harder to fake both of them for the same artifact.
2. you might want to add generated checksums to the list above
3. when _updating_ dependency verification file with more secure checksums, you don't want to accidentally erase checksums

[[sec:signature-verification]]
== Verifying dependency signatures

In addition to <<sec:checksum-verification,checksums>>, Gradle supports verification of signatures.
Signatures are used to assess the _provenance_ of a dependency (it tells who signed the artifacts, which usually corresponds to who produced it).

As enabling signature verification usually means a higher level of security, you might want to replace checksum verification with signature verification.

[WARNING]
====
Signatures _can_ also be used to assess the integrity of a dependency similarly to checksums.
Signatures are signatures of the _hash_ of artifacts, not artifacts themselves.
This means that if the signature is done on an _unsafe hash_ (even SHA1), then you're not correctly assessing the _integrity_ of a file.
For this reason, if you care about both, you need to add both signatures _and_ checksums to your verification metadata.
====

However:

- Gradle only supports verification of signatures published on remote repositories as ASCII-armored PGP files
- Not all artifacts are published with signatures
- A good signature doesn't mean that the signatory was legit

As a consequence, signature verification will often be used alongside checksum verification.

[NOTE]
.About expired keys
====
It's very common to find artifacts which are signed with an expired key.
This is not a problem for _verification_: key expiry is mostly used to avoid signing with a stolen key.
If an artifact was signed before expiry, it's still valid.
====

=== Enabling signature verification

Because verifying signatures is more expensive (both I/O and CPU wise) and harder to check manually, it's not enabled by default.

Enabling it requires you to change the configuration option in the `verification-metadata.xml` file:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <verify-signatures>true</verify-signatures>
   </configuration>
</verification-metadata>
----

[[sec:understanding-signature-verification]]
== Understanding signature verification

Once signature verification is enabled, for each artifact, Gradle will:

* try to download the corresponding `.asc` file
* if it's present
** automatically download the keys required to perform verification of the signature
** verify the artifact using the downloaded public keys
** if signature verification passes, perform additional requested checksum verification
* if it's absent, fallback to checksum verification

That is to say that Gradle's verification mechanism is much stronger if signature verification is enabled than just with checksum verification.
In particular:

- if an artifact is signed with multiple keys, all of them must pass validation or the build will fail
- if an artifact passes verification, any additional checksum configured for the artifact _will also be checked_

However, it's not because an artifact passes signature verification that you can trust it: you need to _trust the keys_.

In practice, it means you need to list the keys that you trust for each artifact, which is done by adding a `pgp` entry instead of a `sha1` for example:

[source,xml]
----
<component group=""com.github.javaparser"" name=""javaparser-core"" version=""3.6.11"">
   <artifact name=""javaparser-core-3.6.11.jar"">
      <pgp value=""8756c4f765c9ac3cb6b85d62379ce192d401ab61""/>
   </artifact>
</component>
----

[TIP]
====
Gradle supports both full fingerprint ids or long (64-bit) key ids in `pgp`, `trusted-key` and `ignore-key` elements.
For maximum security, you should use full fingerprints as it's possible to have collisions for long key ids.
====

This effectively means that you trust `com.github.javaparser:javaparser-core:3.6.11` if it's signed with the key `8756c4f765c9ac3cb6b85d62379ce192d401ab61`.

Without this, the build would fail with this error:

----
> Dependency verification failed for configuration ':compileClasspath':
    - On artifact javaparser-core-3.6.11.jar (com.github.javaparser:javaparser-core:3.6.11) in repository 'MavenRepo': Artifact was signed with key '8756c4f765c9ac3cb6b85d62379ce192d401ab61' (Bintray (by JFrog) <****>) and passed verification but the key isn't in your trusted keys list.
----

[NOTE]
====
The key IDs that Gradle shows in error messages are the key IDs found in the signature file it tries to verify.
It doesn't mean that it's necessarily the keys that you should trust.
In particular, if the signature is correct but done by a malicious entity, Gradle wouldn't tell you.
====

[[sec:trusting-keys-globally]]
=== Trusting keys globally

Signature verification has the advantage that it can make the configuration of dependency verification easier by not having to explicitly list all artifacts like for checksum verification only.
In fact, it's common that the same key can be used to sign several artifacts.
If this is the case, you can move the trusted key from the artifact level to the global configuration block:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <verify-metadata>true</verify-metadata>
      <verify-signatures>true</verify-signatures>
      <trusted-keys>
         <trusted-key id=""379ce192d401ab61"" group=""com.github.javaparser""/>
      </trusted-keys>
   </configuration>
   <components/>
</verification-metadata>
----

The configuration above means that for any artifact belonging to the group `com.github.javaparser`, we trust it if it's signed with the `379ce192d401ab61`.

The `trusted-key` element works similarly to the <<sec:trusting-artifacts,trusted-artifact>> element:

- `group`, the group of the artifact to trust
- `name`, the name of the artifact to trust
- `version`, the version of the artifact to trust
- `file`, the name of the artifact _file_ to trust
- `regex`, a boolean saying if the `group`, `name`, `version` and `file` attributes need to be interpreted as regular expressions (defaults to `false`)

[WARNING]
====
You should be careful when trusting a key globally: try to limit it to the appropriate groups or artifacts:

- a valid key may have been used to sign artifact `A` which you trust
- later on, the key is stolen and used to sign artifact `B`

It means you can trust the key `A` for the first artifact, probably only up to the released version before the key was stolen, but not for `B`.

Remember that anybody can put an arbitrary name when generating a PGP key, so never trust the key solely based on the key name.
Verify if the key is listed at the official site.
For example, Apache projects typically provide a KEYS.txt file that you can trust.
====

[[sec:ignoring-keys]]
=== Specifying key servers and ignoring keys

Gradle will automatically download the public keys required to verify a signature.
For this it uses a list of well known and trusted key servers (the list may change between Gradle versions, please refer to the implementation to figure out what servers are used by default).

You can explicitly set the list of key servers that you want to use by adding them to the configuration:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <verify-metadata>true</verify-metadata>
      <verify-signatures>true</verify-signatures>
      <key-servers>
         <key-server uri=""hkp://my-key-server.org""/>
         <key-server uri=""https://my-other-key-server.org""/>
      </key-servers>
   </configuration>
</verification-metadata>
----

Despite this, it's possible that a key is not available:

- because it wasn't published to a public key server
- because it was lost

In this case, you can ignore a key in the configuration block:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <verify-metadata>true</verify-metadata>
      <verify-signatures>true</verify-signatures>
      <ignored-keys>
         <ignored-key id=""abcdef1234567890"" reason=""Key is not available in any key server""/>
      </ignored-keys>
   </configuration>
</verification-metadata>
----

As soon as a key is ignored, it will not be used for verification, even if the signature file mentions it.
However, if the signature cannot be verified with at least one other key, Gradle will mandate that you provide a checksum.

[[sec:local-keyring]]
=== Exporting keys for faster verification

Gradle automatically downloads the required keys but this operation can be quite slow and requires everyone to download the keys.
To avoid this, Gradle offers the ability to use a local keyring file containing the required public keys.

Gradle supports 2 different file formats for keyrings: a binary format (`.gpg` file) and a plain text format (`.keys`).

There are pros and cons for each of the formats: the binary format is more compact and can be updated directly via GPG commands, but is completely opaque (binary).
On the opposite, the plain text format is human readable, can be easily updated by hand and makes it easier to do code reviews thanks to readable diffs.

If the `gradle/verification-keyring.gpg` or `gradle/verification-keyring.keys` file is present, Gradle will search for keys there in priority.

Note that the plain text file will be ignored if there's already a `.gpg` file (the binary version takes precedence).

You can generate the binary version using GPG, for example issuing the following commands (syntax may depend on the tool you use):

[source,bash]
----
$ gpg --no-default-keyring --keyring gradle/verification-keyring.gpg --recv-keys 379ce192d401ab61

gpg: keybox 'gradle/verification-keyring.gpg' created
gpg: key 379CE192D401AB61: public key ""Bintray (by JFrog) <****>"" imported
gpg: Total number processed: 1
gpg:               imported: 1

$ gpg --no-default-keyring --keyring gradle/verification-keyring.gpg --recv-keys 6a0975f8b1127b83

gpg: key 0729A0AFF8999A87: public key ""Kotlin Release <****>"" imported
gpg: Total number processed: 1
gpg:               imported: 1
----

The plain text version, on the other hand, can be updated manually.
The file must be formatted with the `US-ASCII` encoding and consists of a list of keys in ASCII armored format.

In the example above, you could amend an existing KEYS file by issuing the following commands:

[source,bash]
----
$ gpg --no-default-keyring --keyring /tmp/keyring.gpg --recv-keys 379ce192d401ab61

gpg: keybox '/tmp/keyring.gpg' created
gpg: key 379CE192D401AB61: public key ""Bintray (by JFrog) <****>"" imported
gpg: Total number processed: 1
gpg:               imported: 1

# First let's add a header so that we can recognize the added key
$ gpg --keyring /tmp/keyring.gpg --list-sigs 379CE192D401AB61 > gradle/verification-keyring.keys

# Then write its ASCII armored version
$ gpg --keyring /tmp/keyring.gpg --export --armor 379CE192D401AB61 > gradle/verification-keyring.keys
----

Or, alternatively, you can _ask Gradle to export all keys it used for verification of this build to the keyring_ during bootstrapping:

----
./gradlew --write-verification-metadata pgp,sha256 --export-keys
----

[NOTE]
====
This command will generate *both* the binary version and the ASCII armored file.
You should only pick one for your project.

It's a good idea to commit this file to VCS (as long as you trust your VCS).
If you use git and use the binary version, make sure to make it treat this file as binary, by adding this to your `.gitattributes` file:

----
*.gpg           binary
----
====

[[sec:bootstrapping-signature-verification]]
=== Bootstrapping and signature verification

[WARNING]
====
Signature verification bootstrapping takes an _optimistic point of view_ that signature verification is _enough_.
Therefore, if you also care about _integrity_, you **must** first bootstrap using checksum verification, _then_ with signature verification.
====

Similarly to bootstrapping for checksums, Gradle provides a convenience for bootstrapping a configuration file with signature verification enabled.
For this, just add the `pgp` option to the list of verifications to generate.
However, because there might be verification failures, missing keys or missing signature files, you **must** provide a fallback checksum verification algorithm:

----
./gradlew --write-verification-metadata pgp,sha256
----

this means that Gradle will verify the signatures and fallback to SHA-256 checksums when there's a problem.

When bootstrapping, Gradle performs _optimistic verification_ and therefore assumes a sane build environment.
It will therefore:

- automatically add the trusted keys as soon as verification passes
- automatically add ignored keys for keys which couldn't be downloaded from public key servers
- automatically generate checksums for artifacts without signatures or ignored keys

If, for some reason, verification fails during the generation, Gradle will automatically generate an ignored key entry but warn you that you must absolutely check what happens.

This situation is common as explained for <<sec:trusting-several-checksums,this section>>: a typical case is when the POM file for a dependency differs from one repository to the other (often in a non-meaningful way).

In addition, Gradle will try to group keys automatically and generate the `trusted-keys` block which reduced the configuration file size as much as possible.

[[sec:local-keyring-only]]
== Forcing use of local keyrings only

The local keyring files (`.gpg` or `.keys`) can be used to avoid reaching out to key servers whenever a key is required to verify an artifact.
However, it may be that the local keyring doesn't contain a key, in which case Gradle would use the key servers to fetch the missing key.
If the local keyring file isn't regularly updated, using <<sec:local-keyring,key export>>, then it may be that your CI builds, for example, would reach out to key servers too often (especially if you use disposable containers for builds).

To avoid this, Gradle offers the ability to disallow use of key servers altogether: only the local keyring file would be used, and if a key is missing from this file, the build will fail.

To enable this mode, you need to disable key servers in the configuration file:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <key-servers enabled=""false""/>
      ...
   </configuration>
   ...
</verification-metadata>
----

NOTE: If you are asking Gradle to <<sec:bootstrapping-verification,generate a verification metadata file>> and that an existing verification metadata file sets `enabled` to `false`, then this flag will be ignored, so that potentially missing keys are downloaded.

[[sec:troubleshooting-verification]]
== Troubleshooting dependency verification

[[sec:dealing-verification-failure]]
=== Dealing with a verification failure

Dependency verification can fail in different ways, this section explains how you should deal with the various cases.

==== Missing verification metadata

The simplest failure you can have is when verification metadata is missing from the dependency verification file.
This is the case for example if you use <<sec:checksum-verification,checksum verification>>, then you update a dependency and new versions of the dependency (and potentially its transitive dependencies) are brought in.

Gradle will tell you what metadata is missing:


----
Execution failed for task ':compileJava'.
> Dependency verification failed for configuration ':compileClasspath':
    - On artifact commons-logging-1.2.jar (commons-logging:commons-logging:1.2) in repository 'MavenRepo': checksum is missing from verification metadata.
----

- the missing module group is `commons-logging`, it's artifact name is `commons-logging` and its version is `1.2`. The corresponding artifact is `commons-logging-1.2.jar` so you need to add the following entry to the verification file:

[source,xml]
----
<component group=""commons-logging"" name=""commons-logging"" version=""1.2"">
   <artifact name=""commons-logging-1.2.jar"">
      <sha256 value=""daddea1ea0be0f56978ab3006b8ac92834afeefbd9b7e4e6316fca57df0fa636"" origin=""official distribution""/>
   </artifact>
</component>
----

Alternatively, you can ask Gradle to generate the missing information by using the <<#sec:bootstrapping-verification,bootstrapping mechanism>>: existing information in the metadata file will be preserved, Gradle will only add the missing verification metadata.

==== Incorrect checksums

A more problematic issue is when the actual checksum verification fails:


----
Execution failed for task ':compileJava'.
> Dependency verification failed for configuration ':compileClasspath':
    - On artifact commons-logging-1.2.jar (commons-logging:commons-logging:1.2) in repository 'MavenRepo': expected a 'sha256' checksum of '91f7a33096ea69bac2cbaf6d01feb934cac002c48d8c8cfa9c240b40f1ec21df' but was 'daddea1ea0be0f56978ab3006b8ac92834afeefbd9b7e4e6316fca57df0fa636'
----

This time, Gradle tells you what dependency is at fault, what was the expected checksum (the one you declared in the verification metadata file) and the one which was actually computed during verification.

Such a failure indicates that a **dependency may have been compromised**.
At this stage, you **must** perform manual verification and check what happens.
Several things can happen:

* a dependency was tampered in the local dependency cache of Gradle. This is usually harmless: erase the file from the cache and Gradle would redownload the dependency.
* a dependency is available in multiple sources with slightly different binaries (additional whitespace, ...)
** please inform the maintainers of the library that they have such an issue
** you can use <<#sec:trusting-several-checksums,`also-trust`>> to accept the additional checksums
* the dependency was compromised
** immediately inform the maintainers of the library
** notify the repository maintainers of the compromised library

Note that a variation of a compromised library is often _name squatting_, when a hacker would use GAV coordinates which _look legit_ but are actually different by one character, or _repository shadowing_, when a dependency with the official GAV coordinates is published in a malicious repository which comes first in your build.

==== Untrusted signatures

If you have signature verification enabled, Gradle will perform verification of the signatures but will not trust them automatically:


----
> Dependency verification failed for configuration ':compileClasspath':
    - On artifact javaparser-core-3.6.11.jar (com.github.javaparser:javaparser-core:3.6.11) in repository 'MavenRepo': Artifact was signed with key '379ce192d401ab61' (Bintray (by JFrog) <****>) and passed verification but the key isn't in your trusted keys list.
----

In this case it means you need to check yourself if the key that was used for verification (and therefore the signature) can be trusted, in which case refer to <<#sec:understanding-signature-verification,this section of the documentation>> to figure out how to declare trusted keys.

==== Failed signature verification

If Gradle fails to verify a signature, you will need to take action and verify artifacts manually because this **may indicate a compromised dependency**.

If such a thing happens, Gradle will fail with:

----
> Dependency verification failed for configuration ':compileClasspath':
    - On artifact javaparser-core-3.6.11.jar (com.github.javaparser:javaparser-core:3.6.11) in repository 'MavenRepo': Artifact was signed with key '379ce192d401ab61' (Bintray (by JFrog) <****>) but signature didn't match
----

There are several options:

1. signature was wrong in the first place, which happens frequently with <<#sec:trusting-several-checksums,dependencies published on different repositories>>.
2. the signature is correct but the artifact has been compromised (either in the local dependency cache or remotely)

The right approach here is to go to the official site of the dependency and see if they publish signatures for their artifacts.
If they do, verify that the signature that Gradle downloaded matches the one published.

If you have <<#sec:manual-checking-dependency,checked that the dependency is _not_ compromised>> and that it's ""only"" the signature which is wrong, you should declare an _artifact level key exclusion_:

[source,xml]
----
   <components>
       <component group=""com.github.javaparser"" name=""javaparser-core"" version=""3.6.11"">
          <artifact name=""javaparser-core-3.6.11.pom"">
             <ignored-keys>
                <ignored-key id=""379ce192d401ab61"" reason=""internal repo has corrupted POM""/>
             </ignored-keys>
          </artifact>
       </component>
   </components>
----

However, if you only do so, Gradle will still fail because all keys for this artifact will be ignored and you didn't provide a checksum:

[source,xml]
----
   <components>
       <component group=""com.github.javaparser"" name=""javaparser-core"" version=""3.6.11"">
          <artifact name=""javaparser-core-3.6.11.pom"">
             <ignored-keys>
                <ignored-key id=""379ce192d401ab61"" reason=""internal repo has corrupted POM""/>
             </ignored-keys>
             <sha256 value=""a2023504cfd611332177f96358b6f6db26e43d96e8ef4cff59b0f5a2bee3c1e1""/>
          </artifact>
       </component>
   </components>
----

[[sec:manual-checking-dependency]]
==== Manual verification of a dependency

You will likely face a dependency verification failure (either checksum verification or signature verification) and will need to figure out if the dependency has been compromised or not.

In this section we give _an example_ how you can manually check if a dependency was compromised.

For this we will take this example failure:

----
> Dependency verification failed for configuration ':compileClasspath':
- On artifact j2objc-annotations-1.1.jar (com.google.j2objc:j2objc-annotations:1.1) in repository 'MyCompany Mirror': Artifact was signed with key '29579f18fa8fd93b' but signature didn't match
----

This error message gives us the GAV coordinates of the problematic dependency, as well as an indication of where the dependency was fetched from.
Here, the dependency comes from `MyCompany Mirror`, which is a repository declared in our build.

The first thing to do is therefore to download the artifact and its signature manually from the mirror:

----
$ curl https://my-company-mirror.com/repo/com/google/j2objc/j2objc-annotations/1.1/j2objc-annotations-1.1.jar --output j2objc-annotations-1.1.jar
$ curl https://my-company-mirror.com/repo/com/google/j2objc/j2objc-annotations/1.1/j2objc-annotations-1.1.jar.asc --output j2objc-annotations-1.1.jar.asc
----

Then we can use the key information provided in the error message to import the key locally:

----
$ gpg --recv-keys 29579f18fa8fd93b
----

And perform verification:

----
$ gpg --verify j2objc-annotations-1.1.jar.asc
gpg: assuming signed data in 'j2objc-annotations-1.1.jar'
gpg: Signature made Thu 19 Jan 2017 12:06:51 AM CET
gpg:                using RSA key 29579F18FA8FD93B
gpg: BAD signature from ""Tom Ball <****>"" [unknown]
----

What this tells us is that the problem is _not_ on the local machine: the repository _already contains a bad signature_.

The next step is to do the same by downloading what is actually on Maven Central:

----
$ curl https://my-company-mirror.com/repo/com/google/j2objc/j2objc-annotations/1.1/j2objc-annotations-1.1.jar  --output central-j2objc-annotations-1.1.jar
$ curl https://my-company-mirror.com/repo/com/google/j2objc/j2objc-annotations/1/1/j2objc-annotations-1.1.jar.asc  --output central-j2objc-annotations-1.1.jar.asc
----

And we can now check the signature again:

----
$ gpg --verify central-j2objc-annotations-1.1.jar.asc

gpg: assuming signed data in 'central-j2objc-annotations-1.1.jar'
gpg: Signature made Thu 19 Jan 2017 12:06:51 AM CET
gpg:                using RSA key 29579F18FA8FD93B
gpg: Good signature from ""Tom Ball <****>"" [unknown]
gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.
Primary key fingerprint: B801 E2F8 EF03 5068 EC11  39CC 2957 9F18 FA8F D93B
----

This indicates that the dependency is _valid_ on Maven Central.
At this stage, we already know that the problem lives in the mirror, it _may_ have been compromised, but we need to verify.

A good idea is to compare the 2 artifacts, which you can do with a tool like https://try.diffoscope.org/[diffoscope].

We then figure out that the intent wasn't malicious but that somehow a build has been overwritten with a newer version (the version in Central is newer than the one in our repository).

In this case, you can decide to:

- ignore the signature for this artifact and trust the different possible checksums (both for the old artifact and the new version)
- or cleanup your mirror so that it contains the same version as in Maven Central

It's worth noting that if you choose to delete the version from your repository, you will _also_ need to remove it from the local Gradle cache.

This is facilitated by the fact the error message tells you were the file is located:

----
> Dependency verification failed for configuration ':compileClasspath':
    - On artifact j2objc-annotations-1.1.jar (com.google.j2objc:j2objc-annotations:1.1) in repository 'MyCompany Mirror': Artifact was signed with key '29579f18fa8fd93b' but signature didn't match

  This can indicate that a dependency has been compromised. Please carefully verify the signatures and checksums.

  For your information here are the path to the files which failed verification:
    - GRADLE_USER_HOME/caches/modules-2/files-2.1/com.google.j2objc/j2objc-annotations/1.1/976d8d30bebc251db406f2bdb3eb01962b5685b3/j2objc-annotations-1.1.jar (signature: GRADLE_USER_HOME/caches/modules-2/files-2.1/com.google.j2objc/j2objc-annotations/1.1/82e922e14f57d522de465fd144ec26eb7da44501/j2objc-annotations-1.1.jar.asc)

  GRADLE_USER_HOME = /home/jiraya/.gradle
----

You can safely delete the artifact file as Gradle would automatically re-download it:

----
rm -rf ~/.gradle/caches/modules-2/files-2.1/com.google.j2objc/j2objc-annotations/1.1
----

[[sec:disabling-verification]]
=== Disabling verification or making it lenient

Dependency verification can be expensive, or sometimes verification could get in the way of day to day development (because of frequent dependency upgrades, for example).

Alternatively, you might want to enable verification on CI servers but not on local machines.

Gradle actually provides 3 different verification modes:

- `strict`, which is the default.
Verification fails _as early as possible_, in order to avoid the use of compromised dependencies during the build.
- `lenient`, which will run the build even if there are verification failures.
The verification errors will be displayed during the build without causing a build failure.
- `off` when verification is totally ignored.

All those modes can be activated on the CLI using the `--dependency-verification` flag, for example:


----
./gradlew --dependency-verification lenient build
----

Alternatively, you can set the `org.gradle.dependency.verification` system property, either on the CLI:


----
./gradlew -Dorg.gradle.dependency.verification=lenient build
----

or in a `gradle.properties` file:

----
org.gradle.dependency.verification=lenient
----

[[sec:trusting-artifacts]]
=== Trusting some particular artifacts

You might want to trust some artifacts more than others.
For example, it's legitimate to think that artifacts produced in your company and found in your internal repository only are safe, but you want to check every external component.

[NOTE]
====
This is a typical _company policy_.
In practice, **nothing** prevents your internal repository from being compromised, so it's a good idea to check your internal artifacts too!
====

For this purpose, Gradle offers a way to automatically trust some artifacts.
You can trust all artifacts in a group by adding this to your configuration:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <trusted-artifacts>
         <trust group=""com.mycompany""/>
      </trusted-artifacts>
   </configuration>
</verification-metadata>
----

This means that all components which group is `com.mycompany` will automatically be trusted.
Trusted means that Gradle will not perform any verification whatsoever.

The `trust` element accepts those attributes:

- `group`, the group of the artifact to trust
- `name`, the name of the artifact to trust
- `version`, the version of the artifact to trust
- `file`, the name of the artifact _file_ to trust
- `regex`, a boolean saying if the `group`, `name`, `version` and `file` attributes need to be interpreted as regular expressions (defaults to `false`)

In the example above it means that the trusted artifacts would be artifacts in `com.mycompany` but not `com.mycompany.other`.
To trust all artifacts in `com.mycompany` and all subgroups, you can use:

[source,xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<verification-metadata>
   <configuration>
      <trusted-artifacts>
         <trust group=""^com[.]mycompany($|([.].*))"" regex=""true""/>
      </trusted-artifacts>
   </configuration>
</verification-metadata>
----

[[sec:trusting-several-checksums]]
=== Trusting multiple checksums for an artifact

It's quite common to have _different checksums for the same artifact_ in the wild.
How is that possible?
Despite progress, it's often the case that developers publish, for example, to Maven Central and another repository separately, using different builds.
In general, this is not a problem but sometimes it means that the metadata files would be different (different timestamps, additional whitespaces, ...).
Add to this that your build may use several repositories or repository mirrors and it makes it quite likely that a single build can ""see"" different metadata files for the same component!
In general, it's not malicious (but you **must** verify that the artifact is actually correct), so Gradle lets you declare the additional artifact checksums.
For example:

[source,xml]
----
      <component group=""org.apache"" name=""apache"" version=""13"">
         <artifact name=""apache-13.pom"">
            <sha256 value=""2fafa38abefe1b40283016f506ba9e844bfcf18713497284264166a5dbf4b95e"">
               <also-trust value=""ff513db0361fd41237bef4784968bc15aae478d4ec0a9496f811072ccaf3841d""/>
            </sha256>
         </artifact>
      </component>
----

You can have as many `also-trust` entries as needed, but in general you shouldn't have more than 2.

[[sec:skipping-javadocs]]
=== Skipping Javadocs and sources

By default Gradle will verify _all_ downloaded artifacts, which includes Javadocs and sources.
In general this is not a problem but you might face an issue with IDEs which automatically try to download them during import: if you didn't set the checksums for those too, importing would fail.

To avoid this, you can configure Gradle to trust automatically all javadocs/sources:

[source,xml]
----
<trusted-artifacts>
   <trust file="".*-javadoc[.]jar"" regex=""true""/>
   <trust file="".*-sources[.]jar"" regex=""true""/>
</trusted-artifacts>
----

[[sec:verification-metadata-hygiene]]
=== Cleaning up the verification file

If you do nothing, the dependency verification metadata will grow over time as you add new dependencies or change versions: Gradle will not automatically remove _unused_ entries from this file.
The reason is that there's no way for Gradle to know upfront if a dependency will effectively be used during the build or not.

As a consequence, adding dependencies or changing dependency version can easily lead to more entries in the file, while leaving unnecessary entries out there.

One option to cleanup the file is to move the existing `verification-metadata.xml` file to a different location and call Gradle with the <<#sec:verification-dry-mode,`--dry-run` mode>>: while not perfect (it will not notice dependencies only resolved at configuration time), it generates _a new file_ that you can compare with the existing one.

We need to move the existing file because both the bootstrapping mode and the dry-run mode are incremental: they copy information from the existing metadata verification file (in particular, trusted keys).

[[sec:refreshing-missing-keys]]
=== Refreshing missing keys

Gradle caches missing keys for 24 hours, meaning it will not attempt to re-download the missing keys for 24 hours after failing.

If you want to retry immediately, you can run with the `--refresh-keys` CLI flag:


----
./gradlew build --refresh-keys
----

[[sub:disabling-specific-verification]]
== Disabling dependency verification for some configurations only

In order to provide the strongest security level possible, dependency verification is enabled globally.
This will ensure, for example, that you trust all the plugins you use.
However, the plugins themselves may need to resolve additional dependencies that it doesn't make sense to ask the user to accept.
For this purpose, Gradle provides an API which allows _disabling dependency verification on some specific configurations_.

[WARNING]
====
Disabling dependency verification, if you care about security, is not a good idea.
This API mostly exist for cases where it doesn't make sense to check dependencies.
However, in order to be on the safe side, Gradle will systematically print a warning whenever verification has been disabled for a specific configuration.
====

As an example, a plugin may want to check if there are _newer_ versions of a library available and list those versions.
It doesn't make sense, in this context, to ask the user to put the checksums of the POM files of the newer releases because by definition, they don't know about them.
So the plugin might need to run its code _independently of the dependency verification configuration_.

To do this, you need to call the `ResolutionStrategy#disableDependencyVerification` method:

.Disabling dependency verification
====
include::sample[dir=""snippets/dependencyManagement/dependencyVerification-disablingVerification/groovy"",files=""build.gradle[tags=disabling-one-configuration]""]
include::sample[dir=""snippets/dependencyManagement/dependencyVerification-disablingVerification/kotlin"",files=""build.gradle.kts[tags=disabling-one-configuration]""]
====

It's also possible to disable verification on detached configurations like in the following example:

.Disabling dependency verification
====
include::sample[dir=""snippets/dependencyManagement/dependencyVerification-disablingVerification/groovy"",files=""build.gradle[tags=disabling-detached-configuration]""]
include::sample[dir=""snippets/dependencyManagement/dependencyVerification-disablingVerification/kotlin"",files=""build.gradle.kts[tags=disabling-detached-configuration]""]
====
",12118,False,2383.218880248348,median
"//---------------------------------------------------------------------------
//	Greenplum Database
//	Copyright (C) 2018 VMware, Inc. or its affiliates.
//
//	@filename:
//		CFilterCardinalityTest.cpp
//
//	@doc:
//		Test for filter cardinality estimation
//---------------------------------------------------------------------------

#ifndef __STDC_CONSTANT_MACROS
#define __STDC_CONSTANT_MACROS
#endif

#include <stdint.h>

#include ""gpos/io/COstreamString.h""
#include ""gpos/string/CWStringDynamic.h""

#include ""naucrates/statistics/CStatisticsUtils.h""
#include ""naucrates/statistics/CFilterStatsProcessor.h""
#include ""naucrates/dxl/CDXLUtils.h""

#include ""unittest/base.h""
#include ""unittest/dxl/statistics/CCardinalityTestUtils.h""
#include ""unittest/dxl/statistics/CStatisticsTest.h""
#include ""unittest/dxl/statistics/CFilterCardinalityTest.h""

#include ""unittest/gpopt/CTestUtils.h""

using namespace gpopt;

// DXL files
const CHAR *szInputDXLFileName =
	""../data/dxl/statistics/Basic-Statistics-Input.xml"";
const CHAR *szOutputDXLFileName =
	""../data/dxl/statistics/Basic-Statistics-Output.xml"";

const CTestUtils::STestCase rgtcStatistics[] = {
	{""../data/dxl/statistics/Numeric-Input.xml"",
	 ""../data/dxl/statistics/Numeric-Output-LT-MinBoundary.xml""},
	{""../data/dxl/statistics/Numeric-Input.xml"",
	 ""../data/dxl/statistics/Numeric-Output-LTE-MinBoundary.xml""},
	{""../data/dxl/statistics/Numeric-Input.xml"",
	 ""../data/dxl/statistics/Numeric-Output-E-MinBoundary.xml""},
	{""../data/dxl/statistics/Numeric-Input.xml"",
	 ""../data/dxl/statistics/Numeric-Output-GT-MaxBoundary.xml""},
	{""../data/dxl/statistics/Numeric-Input.xml"",
	 ""../data/dxl/statistics/Numeric-Output-GTE-MaxBoundary.xml""},
	{""../data/dxl/statistics/Numeric-Input.xml"",
	 ""../data/dxl/statistics/Numeric-Output-E-MaxBoundary.xml""},

	{""../data/dxl/statistics/Numeric-Input2.xml"",
	 ""../data/dxl/statistics/Numeric-Output-2-LT-MinBoundary.xml""},
	{""../data/dxl/statistics/Numeric-Input2.xml"",
	 ""../data/dxl/statistics/Numeric-Output-2-LTE-MinBoundary.xml""},
	{""../data/dxl/statistics/Numeric-Input2.xml"",
	 ""../data/dxl/statistics/Numeric-Output-2-E-MinBoundary.xml""},
	{""../data/dxl/statistics/Numeric-Input2.xml"",
	 ""../data/dxl/statistics/Numeric-Output-2-GT-MinBoundary.xml""},
	{""../data/dxl/statistics/Numeric-Input2.xml"",
	 ""../data/dxl/statistics/Numeric-Output-2-GTE-MinBoundary.xml""},

	{""../data/dxl/statistics/Numeric-Input2.xml"",
	 ""../data/dxl/statistics/Numeric-Output-2-LT-MaxBoundary.xml""},
	{""../data/dxl/statistics/Numeric-Input2.xml"",
	 ""../data/dxl/statistics/Numeric-Output-2-LTE-MaxBoundary.xml""},
	{""../data/dxl/statistics/Numeric-Input2.xml"",
	 ""../data/dxl/statistics/Numeric-Output-2-GT-MaxBoundary.xml""},
	{""../data/dxl/statistics/Numeric-Input2.xml"",
	 ""../data/dxl/statistics/Numeric-Output-2-GTE-MaxBoundary.xml""},
	{""../data/dxl/statistics/Numeric-Input2.xml"",
	 ""../data/dxl/statistics/Numeric-Output-2-E-MaxBoundary.xml""},
};

// unittest for statistics objects
GPOS_RESULT
CFilterCardinalityTest::EresUnittest()
{
	// tests that use shared optimization context
	CUnittest rgutSharedOptCtxt[] = {
		GPOS_UNITTEST_FUNC(CFilterCardinalityTest::
							   EresUnittest_CStatisticsBasicsFromDXLNumeric),
		GPOS_UNITTEST_FUNC(
			CFilterCardinalityTest::EresUnittest_CStatisticsFilter),
		GPOS_UNITTEST_FUNC(
			CFilterCardinalityTest::EresUnittest_CStatisticsFilterArrayCmpAny),
		GPOS_UNITTEST_FUNC(
			CFilterCardinalityTest::EresUnittest_CStatisticsFilterConj),
		GPOS_UNITTEST_FUNC(
			CFilterCardinalityTest::EresUnittest_CStatisticsFilterDisj),
		GPOS_UNITTEST_FUNC(
			CFilterCardinalityTest::EresUnittest_CStatisticsNestedPred),
		GPOS_UNITTEST_FUNC(
			CFilterCardinalityTest::EresUnittest_CStatisticsBasicsFromDXL),
		GPOS_UNITTEST_FUNC(
			CFilterCardinalityTest::EresUnittest_CStatisticsAccumulateCard)};

	CAutoMemoryPool amp;
	CMemoryPool *mp = amp.Pmp();

	// setup a file-based provider
	CMDProviderMemory *pmdp = CTestUtils::m_pmdpf;
	pmdp->AddRef();
	CMDAccessor mda(mp, CMDCache::Pcache(), CTestUtils::m_sysidDefault, pmdp);

	// install opt context in TLS
	CAutoOptCtxt aoc(mp, &mda, NULL /* pceeval */,
					 CTestUtils::GetCostModel(mp));

	return CUnittest::EresExecute(rgutSharedOptCtxt,
								  GPOS_ARRAY_SIZE(rgutSharedOptCtxt));
}

// reads a DXL document, generates the statistics object, performs a
// filter operation on it, serializes it into a DXL document and
// compares the generated DXL document with the expected DXL document.
GPOS_RESULT
CFilterCardinalityTest::EresUnittest_CStatistics(
	SStatsFilterSTestCase rgstatsdisjtc[], ULONG ulTestCases)
{
	// create memory pool
	CAutoMemoryPool amp;
	CMemoryPool *mp = amp.Pmp();

	CWStringDynamic str(mp);
	COstreamString oss(&str);

	CMDAccessor *md_accessor = COptCtxt::PoctxtFromTLS()->Pmda();

	for (ULONG ul = 0; ul < ulTestCases; ul++)
	{
		SStatsFilterSTestCase elem = rgstatsdisjtc[ul];

		// read input/output DXL file
		CHAR *szDXLInput = CDXLUtils::Read(mp, elem.m_szInputFile);
		CHAR *szDXLOutput = CDXLUtils::Read(mp, elem.m_szOutputFile);

		GPOS_CHECK_ABORT;

		// parse the statistics objects
		CDXLStatsDerivedRelationArray *dxl_derived_rel_stats_array =
			CDXLUtils::ParseDXLToStatsDerivedRelArray(mp, szDXLInput, NULL);
		CStatisticsArray *pdrgpstatBefore =
			CDXLUtils::ParseDXLToOptimizerStatisticObjArray(
				mp, md_accessor, dxl_derived_rel_stats_array);
		dxl_derived_rel_stats_array->Release();
		GPOS_ASSERT(NULL != pdrgpstatBefore);

		GPOS_CHECK_ABORT;

		// generate the disjunctive predicate
		FnPstatspredDisj *pf = elem.m_pf;
		GPOS_ASSERT(NULL != pf);
		CStatsPred *disjunctive_pred_stats = pf(mp);

		GPOS_RESULT eres = EresUnittest_CStatisticsCompare(
			mp, md_accessor, pdrgpstatBefore, disjunctive_pred_stats,
			szDXLOutput);

		// clean up
		pdrgpstatBefore->Release();
		disjunctive_pred_stats->Release();
		GPOS_DELETE_ARRAY(szDXLInput);
		GPOS_DELETE_ARRAY(szDXLOutput);

		if (GPOS_FAILED == eres)
		{
			return eres;
		}
	}

	return GPOS_OK;
}

// reads a DXL document, generates the statistics object, performs a
// filter operation on it, serializes it into a DXL document and
// compares the generated DXL document with the expected DXL document.
GPOS_RESULT
CFilterCardinalityTest::EresUnittest_CStatisticsFilter()
{
	SStatsFilterSTestCase rgstatstc[] = {
		{""../data/dxl/statistics/Select-Statistics-Input-Null-Bucket.xml"",
		 ""../data/dxl/statistics/Select-Statistics-Output-Null-Bucket.xml"",
		 PstatspredNullableCols},
		{""../data/dxl/statistics/Select-Statistics-Input-Null-Bucket.xml"",
		 ""../data/dxl/statistics/Select-Statistics-Output-Null-Constant.xml"",
		 PstatspredWithNullConstant},
		{""../data/dxl/statistics/Select-Statistics-Input-Null-Bucket.xml"",
		 ""../data/dxl/statistics/Select-Statistics-Output-NotNull-Constant.xml"",
		 PstatspredNotNull},
	};

	const ULONG ulTestCases = GPOS_ARRAY_SIZE(rgstatstc);

	return EresUnittest_CStatistics(rgstatstc, ulTestCases);
}

// create a filter on a column with null values
CStatsPred *
CFilterCardinalityTest::PstatspredNullableCols(CMemoryPool *mp)
{
	CStatsPredPtrArry *pdrgpstatspred = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	pdrgpstatspred->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptLEq, CTestUtils::PpointInt4(mp, 1)));

	return GPOS_NEW(mp) CStatsPredConj(pdrgpstatspred);
}

// create a point filter where the constant is null
CStatsPred *
CFilterCardinalityTest::PstatspredWithNullConstant(CMemoryPool *mp)
{
	CStatsPredPtrArry *pdrgpstatspred = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	pdrgpstatspred->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4NullVal(mp)));

	return GPOS_NEW(mp) CStatsPredConj(pdrgpstatspred);
}

// create an 'is not null' point filter
CStatsPred *
CFilterCardinalityTest::PstatspredNotNull(CMemoryPool *mp)
{
	CStatsPredPtrArry *pdrgpstatspred = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	pdrgpstatspred->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptNEq, CTestUtils::PpointInt4NullVal(mp)));

	return GPOS_NEW(mp) CStatsPredConj(pdrgpstatspred);
}

// testing ArryCmpAny predicates
GPOS_RESULT
CFilterCardinalityTest::EresUnittest_CStatisticsFilterArrayCmpAny()
{
	SStatsFilterSTestCase rgstatsdisjtc[] = {
		{""../data/dxl/statistics/ArrayCmpAny-Input-1.xml"",
		 ""../data/dxl/statistics/ArrayCmpAny-Output-1.xml"",
		 PstatspredArrayCmpAnySimple},
		{""../data/dxl/statistics/ArrayCmpAny-Input-1.xml"",
		 ""../data/dxl/statistics/ArrayCmpAny-Output-1.xml"",
		 PstatspredArrayCmpAnyDuplicate}};

	const ULONG ulTestCases = GPOS_ARRAY_SIZE(rgstatsdisjtc);

	return EresUnittest_CStatistics(rgstatsdisjtc, ulTestCases);
}

// create a 'col IN (...)' filter without duplicates
CStatsPred *
CFilterCardinalityTest::PstatspredArrayCmpAnySimple(CMemoryPool *mp)
{
	CStatsPredPtrArry *pdrgpstatspred = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	CPointArray *arr = GPOS_NEW(mp) CPointArray(mp);
	arr->Append(CTestUtils::PpointInt4(mp, 1));
	arr->Append(CTestUtils::PpointInt4(mp, 2));
	arr->Append(CTestUtils::PpointInt4(mp, 15));

	pdrgpstatspred->Append(
		GPOS_NEW(mp) CStatsPredArrayCmp(1, CStatsPred::EstatscmptEq, arr));

	return GPOS_NEW(mp) CStatsPredConj(pdrgpstatspred);
}

// create a 'col IN (...)' filter with duplicates (unsorted)
CStatsPred *
CFilterCardinalityTest::PstatspredArrayCmpAnyDuplicate(CMemoryPool *mp)
{
	CStatsPredPtrArry *pdrgpstatspred = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	CPointArray *arr = GPOS_NEW(mp) CPointArray(mp);
	arr->Append(CTestUtils::PpointInt4(mp, 1));
	arr->Append(CTestUtils::PpointInt4(mp, 1));
	arr->Append(CTestUtils::PpointInt4(mp, 15));
	arr->Append(CTestUtils::PpointInt4(mp, 2));
	arr->Append(CTestUtils::PpointInt4(mp, 1));
	arr->Append(CTestUtils::PpointInt4(mp, 1));
	arr->Append(CTestUtils::PpointInt4(mp, 2));
	arr->Append(CTestUtils::PpointInt4(mp, 15));
	arr->Append(CTestUtils::PpointInt4(mp, 15));
	arr->Append(CTestUtils::PpointInt4(mp, 15));

	pdrgpstatspred->Append(
		GPOS_NEW(mp) CStatsPredArrayCmp(1, CStatsPred::EstatscmptEq, arr));

	return GPOS_NEW(mp) CStatsPredConj(pdrgpstatspred);
}

// reads a DXL document, generates the statistics object, performs a
// filter operation on it, serializes it into a DXL document and
// compares the generated DXL document with the expected DXL document.
GPOS_RESULT
CFilterCardinalityTest::EresUnittest_CStatisticsFilterDisj()
{
	SStatsFilterSTestCase rgstatsdisjtc[] = {
		{""../data/dxl/statistics/Disj-Input-1.xml"",
		 ""../data/dxl/statistics/Disj-Output-1.xml"", PstatspredDisj1},
		{""../data/dxl/statistics/Disj-Input-1.xml"",
		 ""../data/dxl/statistics/Disj-Output-1.xml"", PstatspredDisj2},
		{""../data/dxl/statistics/Disj-Input-1.xml"",
		 ""../data/dxl/statistics/Disj-Output-1.xml"", PstatspredDisj3},
		{""../data/dxl/statistics/Disj-Input-2.xml"",
		 ""../data/dxl/statistics/Disj-Output-2-1.xml"", PstatspredDisj4},
		{""../data/dxl/statistics/Disj-Input-2.xml"",
		 ""../data/dxl/statistics/Disj-Output-2-2.xml"", PstatspredDisj5},
		{""../data/dxl/statistics/Disj-Input-2.xml"",
		 ""../data/dxl/statistics/Disj-Output-2-3.xml"", PstatspredDisj6},
		{""../data/dxl/statistics/Disj-Input-2.xml"",
		 ""../data/dxl/statistics/Disj-Output-2-4.xml"", PstatspredDisj7},
		{""../data/dxl/statistics/NestedPred-Input-10.xml"",
		 ""../data/dxl/statistics/Disj-Output-8.xml"", PstatspredDisj8},
		{""../data/dxl/statistics/Disj-Input-2.xml"",
		 ""../data/dxl/statistics/Disj-Output-2-5.xml"", PstatspredDisj9},
	};

	const ULONG ulTestCases = GPOS_ARRAY_SIZE(rgstatsdisjtc);

	return EresUnittest_CStatistics(rgstatsdisjtc, ulTestCases);
}

// create an or filter (no duplicate)
CStatsPred *
CFilterCardinalityTest::PstatspredDisj1(CMemoryPool *mp)
{
	// predicate col_1 in (13, 25, 47, 49);
	INT rgiVal[] = {13, 25, 47, 49};
	const ULONG ulVals = GPOS_ARRAY_SIZE(rgiVal);
	CStatsPredPtrArry *pdrgpstatspredDisj =
		PdrgpstatspredInteger(mp, 1, CStatsPred::EstatscmptEq, rgiVal, ulVals);

	return GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
}

// create an or filter (one duplicate constant)
CStatsPred *
CFilterCardinalityTest::PstatspredDisj2(CMemoryPool *mp)
{
	// predicate col_1 in (13, 13, 25, 47, 49);
	INT rgiVal[] = {13, 13, 25, 47, 49};
	const ULONG ulVals = GPOS_ARRAY_SIZE(rgiVal);
	CStatsPredPtrArry *pdrgpstatspredDisj =
		PdrgpstatspredInteger(mp, 1, CStatsPred::EstatscmptEq, rgiVal, ulVals);

	return GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
}

//	create an or filter (multiple duplicate constants)
CStatsPred *
CFilterCardinalityTest::PstatspredDisj3(CMemoryPool *mp)
{
	// predicate col_1 in (13, 25, 47, 47, 47, 49, 13);
	INT rgiVal[] = {13, 25, 47, 47, 47, 49, 13};
	const ULONG ulVals = GPOS_ARRAY_SIZE(rgiVal);
	CStatsPredPtrArry *pdrgpstatspredDisj =
		PdrgpstatspredInteger(mp, 1, CStatsPred::EstatscmptEq, rgiVal, ulVals);

	return GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
}

// create an or filter
CStatsPred *
CFilterCardinalityTest::PstatspredDisj4(CMemoryPool *mp)
{
	// the predicate is (x <= 5 or x <= 10 or x <= 13) (domain [0 -- 20])
	INT rgiVal[] = {5, 10, 13};
	const ULONG ulVals = GPOS_ARRAY_SIZE(rgiVal);
	CStatsPredPtrArry *pdrgpstatspredDisj =
		PdrgpstatspredInteger(mp, 1, CStatsPred::EstatscmptLEq, rgiVal, ulVals);

	return GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
}

//	create an or filter (multiple LEQ)
CStatsPred *
CFilterCardinalityTest::PstatspredDisj5(CMemoryPool *mp)
{
	// the predicate is (x >= 5 or x >= 13) (domain [0 -- 20])
	INT rgiVal[] = {5, 13};
	const ULONG ulVals = GPOS_ARRAY_SIZE(rgiVal);
	CStatsPredPtrArry *pdrgpstatspredDisj =
		PdrgpstatspredInteger(mp, 1, CStatsPred::EstatscmptGEq, rgiVal, ulVals);

	return GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
}

//	create an or filter
CStatsPred *
CFilterCardinalityTest::PstatspredDisj6(CMemoryPool *mp)
{
	// the predicate is (x > 10 or x < 5) (domain [0 -- 20])
	CStatsPredPtrArry *pdrgpstatspredDisj = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	pdrgpstatspredDisj->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptG, CTestUtils::PpointInt4(mp, 10)));
	pdrgpstatspredDisj->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptL, CTestUtils::PpointInt4(mp, 5)));

	return GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
}

// create an or filter
CStatsPred *
CFilterCardinalityTest::PstatspredDisj7(CMemoryPool *mp)
{
	// the predicate is (x <= 15 or x >= 5 or x > = 10) (domain [0 -- 20])
	INT rgiVal[] = {5, 10};
	const ULONG ulVals = GPOS_ARRAY_SIZE(rgiVal);
	CStatsPredPtrArry *pdrgpstatspredDisj =
		PdrgpstatspredInteger(mp, 1, CStatsPred::EstatscmptGEq, rgiVal, ulVals);
	pdrgpstatspredDisj->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptLEq, CTestUtils::PpointInt4(mp, 15)));

	return GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
}

// create disjunctive predicate on same columns
CStatsPred *
CFilterCardinalityTest::PstatspredDisj8(CMemoryPool *mp)
{
	// predicate is b = 2001 OR b == 2002
	INT rgiVal[] = {2001, 2002};
	const ULONG ulVals = GPOS_ARRAY_SIZE(rgiVal);
	CStatsPredPtrArry *pdrgpstatspredDisj =
		PdrgpstatspredInteger(mp, 61, CStatsPred::EstatscmptEq, rgiVal, ulVals);

	return GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
}

//	create an or filter (multiple LEQ)
CStatsPred *
CFilterCardinalityTest::PstatspredDisj9(CMemoryPool *mp)
{
	// the predicate is (x <= 3 or x <= 10) (domain [0 -- 20])
	INT rgiVal[] = {3, 10};
	const ULONG ulVals = GPOS_ARRAY_SIZE(rgiVal);
	CStatsPredPtrArry *pdrgpstatspredDisj =
		PdrgpstatspredInteger(mp, 1, CStatsPred::EstatscmptLEq, rgiVal, ulVals);

	return GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
}

// reads a DXL document, generates the statistics object, performs a
// filter operation on it, serializes it into a DXL document and
// compares the generated DXL document with the expected DXL document.
GPOS_RESULT
CFilterCardinalityTest::EresUnittest_CStatisticsFilterConj()
{
	SStatsFilterSTestCase rgstatsdisjtc[] = {
		{""../data/dxl/statistics/NestedPred-Input-9.xml"",
		 ""../data/dxl/statistics/NestedPred-Output-9.xml"", PstatspredConj},
	};

	const ULONG ulTestCases = GPOS_ARRAY_SIZE(rgstatsdisjtc);

	return EresUnittest_CStatistics(rgstatsdisjtc, ulTestCases);
}

// create conjunctive predicate
CStatsPred *
CFilterCardinalityTest::PstatspredConj(CMemoryPool *mp)
{
	CWStringDynamic *pstrW =
		GPOS_NEW(mp) CWStringDynamic(mp, GPOS_WSZ_LIT(""AAAABXc=""));

	// predicate is a == 'w' AND b == 2001 AND c > 0
	CStatsPredPtrArry *pdrgpstatspredConj3 = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspredConj3->Append(GPOS_NEW(mp) CStatsPredPoint(
		594, CStatsPred::EstatscmptEq,
		CCardinalityTestUtils::PpointGeneric(mp, GPDB_TEXT, pstrW, 160621100)));
	pdrgpstatspredConj3->Append(GPOS_NEW(mp) CStatsPredPoint(
		592, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 2001)));
	pdrgpstatspredConj3->Append(GPOS_NEW(mp) CStatsPredPoint(
		593, CStatsPred::EstatscmptG, CTestUtils::PpointInt4(mp, 0)));

	GPOS_DELETE(pstrW);

	return GPOS_NEW(mp) CStatsPredConj(pdrgpstatspredConj3);
}

// reads a DXL document, generates the statistics object, performs a
// filter operation on it, serializes it into a DXL document and
// compares the generated DXL document with the expected DXL document.
GPOS_RESULT
CFilterCardinalityTest::EresUnittest_CStatisticsNestedPred()
{
	SStatsFilterSTestCase rgstatsdisjtc[] = {
		{""../data/dxl/statistics/NestedPred-Input-1.xml"",
		 ""../data/dxl/statistics/NestedPred-Output-1.xml"",
		 PstatspredNestedPredDiffCol1},
		{""../data/dxl/statistics/NestedPred-Input-1.xml"",
		 ""../data/dxl/statistics/NestedPred-Output-1.xml"",
		 PstatspredNestedPredDiffCol2},
		{""../data/dxl/statistics/NestedPred-Input-2.xml"",
		 ""../data/dxl/statistics/NestedPred-Output-2.xml"",
		 PstatspredNestedPredCommonCol1},
		{""../data/dxl/statistics/NestedPred-Input-1.xml"",
		 ""../data/dxl/statistics/NestedPred-Output-3.xml"",
		 PstatspredNestedSharedCol},
		{""../data/dxl/statistics/NestedPred-Input-3.xml"",
		 ""../data/dxl/statistics/NestedPred-Output-4.xml"",
		 PstatspredDisjOverConjSameCol1},
		{""../data/dxl/statistics/NestedPred-Input-3.xml"",
		 ""../data/dxl/statistics/NestedPred-Input-3.xml"",
		 PstatspredDisjOverConjSameCol2},
		{""../data/dxl/statistics/NestedPred-Input-1.xml"",
		 ""../data/dxl/statistics/NestedPred-Output-5.xml"",
		 PstatspredDisjOverConjDifferentCol1},
		{""../data/dxl/statistics/NestedPred-Input-1.xml"",
		 ""../data/dxl/statistics/NestedPred-Output-6.xml"",
		 PstatspredDisjOverConjMultipleIdenticalCols},
		{""../data/dxl/statistics/NestedPred-Input-2.xml"",
		 ""../data/dxl/statistics/NestedPred-Output-7.xml"",
		 PstatspredNestedPredCommonCol2},
		{""../data/dxl/statistics/NestedPred-Input-8.xml"",
		 ""../data/dxl/statistics/NestedPred-Output-8.xml"",
		 PstatspredDisjOverConjSameCol3},
		{""../data/dxl/statistics/NestedPred-Input-10.xml"",
		 ""../data/dxl/statistics/NestedPred-Output-10.xml"",
		 PstatspredDisjOverConjSameCol4},
	};

	const ULONG ulTestCases = GPOS_ARRAY_SIZE(rgstatsdisjtc);

	return EresUnittest_CStatistics(rgstatsdisjtc, ulTestCases);
}

//		Create nested AND and OR predicates where the AND and OR predicates
//		are on different columns
CStatsPred *
CFilterCardinalityTest::PstatspredNestedPredDiffCol1(CMemoryPool *mp)
{
	CStatsPredPtrArry *pdrgpstatspredConj = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	// predicate col_1 <> 3
	pdrgpstatspredConj->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptNEq, CTestUtils::PpointInt4(mp, 3)));

	// predicate col_2 in (15, 20, 22, 24, 31, 39, 42, 46);
	INT rgiVal[] = {15, 20, 22, 24, 31, 39, 42, 46};
	const ULONG ulVals = GPOS_ARRAY_SIZE(rgiVal);
	CStatsPredPtrArry *pdrgpstatspredDisj =
		PdrgpstatspredInteger(mp, 2, CStatsPred::EstatscmptEq, rgiVal, ulVals);

	CStatsPredDisj *disjunctive_pred_stats =
		GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
	pdrgpstatspredConj->Append(disjunctive_pred_stats);

	return GPOS_NEW(mp) CStatsPredConj(pdrgpstatspredConj);
}

// create nested AND and OR predicates where the AND and OR predicates
// are on different columns. note: the order of the predicates in
// reversed as in PstatspredNestedPredDiffCol1
CStatsPred *
CFilterCardinalityTest::PstatspredNestedPredDiffCol2(CMemoryPool *mp)
{
	CStatsPredPtrArry *pdrgpstatspredConj = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	// predicate col_2 in (15, 20, 22, 24, 31, 39, 42, 46);
	INT rgiVal[] = {15, 20, 22, 24, 31, 39, 42, 46};
	const ULONG ulVals = GPOS_ARRAY_SIZE(rgiVal);
	CStatsPredPtrArry *pdrgpstatspredDisj =
		PdrgpstatspredInteger(mp, 2, CStatsPred::EstatscmptEq, rgiVal, ulVals);

	CStatsPredDisj *disjunctive_pred_stats =
		GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
	pdrgpstatspredConj->Append(disjunctive_pred_stats);

	// predicate col_1 <> 3
	pdrgpstatspredConj->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptNEq, CTestUtils::PpointInt4(mp, 3)));

	return GPOS_NEW(mp) CStatsPredConj(pdrgpstatspredConj);
}

// create nested AND and OR predicates where the AND and OR predicates
// are on the same columns
CStatsPred *
CFilterCardinalityTest::PstatspredNestedPredCommonCol1(CMemoryPool *mp)
{
	// predicate is col_2 in (39, 31, 24, 22, 46, 20, 42, 15) AND col_2 == 2
	CStatsPredPtrArry *pdrgpstatspredConj = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	// predicate col_2 in (15, 20, 22, 24, 31, 39, 42, 46);
	INT rgiVal[] = {15, 20, 22, 24, 31, 39, 42, 46};
	const ULONG ulVals = GPOS_ARRAY_SIZE(rgiVal);
	CStatsPredPtrArry *pdrgpstatspredDisj =
		PdrgpstatspredInteger(mp, 2, CStatsPred::EstatscmptEq, rgiVal, ulVals);

	CStatsPredDisj *disjunctive_pred_stats =
		GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
	pdrgpstatspredConj->Append(disjunctive_pred_stats);

	// predicate col_2 == 2
	pdrgpstatspredConj->Append(GPOS_NEW(mp) CStatsPredPoint(
		2, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 2)));

	return GPOS_NEW(mp) CStatsPredConj(pdrgpstatspredConj);
}

// create nested AND and OR predicates where the AND and OR predicates
// are on the same columns
CStatsPred *
CFilterCardinalityTest::PstatspredNestedPredCommonCol2(CMemoryPool *mp)
{
	// predicate is col_2 in (2, 39, 31, 24, 22, 46, 20, 42, 15) AND col_2 == 2
	CStatsPredPtrArry *pdrgpstatspredConj = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	// IN predicate: col_2 in (2, 39, 31, 24, 22, 46, 20, 42, 15);
	INT rgiVal[] = {2, 15, 20, 22, 24, 31, 39, 42, 46};
	const ULONG ulVals = GPOS_ARRAY_SIZE(rgiVal);
	CStatsPredPtrArry *pdrgpstatspredDisj =
		PdrgpstatspredInteger(mp, 2, CStatsPred::EstatscmptEq, rgiVal, ulVals);

	CStatsPredDisj *disjunctive_pred_stats =
		GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
	pdrgpstatspredConj->Append(disjunctive_pred_stats);

	// predicate col_2 == 2
	pdrgpstatspredConj->Append(GPOS_NEW(mp) CStatsPredPoint(
		2, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 2)));

	return GPOS_NEW(mp) CStatsPredConj(pdrgpstatspredConj);
}

// create nested AND and OR predicates where the AND and OR predicates
// share common columns
CStatsPred *
CFilterCardinalityTest::PstatspredNestedSharedCol(CMemoryPool *mp)
{
	CStatsPredPtrArry *pdrgpstatspredConj = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	// predicate col_1 <> 3
	pdrgpstatspredConj->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptNEq, CTestUtils::PpointInt4(mp, 3)));

	// predicate col_2 in (15, 20, 22, 24, 31, 39, 42, 46) OR (col_1 == 4));

	INT rgiVal[] = {15, 20, 22, 24, 31, 39, 42, 46};
	const ULONG ulVals = GPOS_ARRAY_SIZE(rgiVal);
	CStatsPredPtrArry *pdrgpstatspredDisj =
		PdrgpstatspredInteger(mp, 2, CStatsPred::EstatscmptEq, rgiVal, ulVals);

	pdrgpstatspredDisj->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 4)));

	CStatsPredDisj *disjunctive_pred_stats =
		GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
	pdrgpstatspredConj->Append(disjunctive_pred_stats);

	return GPOS_NEW(mp) CStatsPredConj(pdrgpstatspredConj);
}

// create nested AND and OR predicates where the AND and OR predicates share common columns
CStatsPred *
CFilterCardinalityTest::PstatspredDisjOverConjSameCol1(CMemoryPool *mp)
{
	CStatsPredPtrArry *pdrgpstatspredConj = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	// predicate col_1 = 3 AND col_1 >=3
	pdrgpstatspredConj->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 3)));
	pdrgpstatspredConj->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptGEq, CTestUtils::PpointInt4(mp, 3)));

	CStatsPredConj *conjunctive_pred_stats =
		GPOS_NEW(mp) CStatsPredConj(pdrgpstatspredConj);

	// predicate (col_1 = 1);
	CStatsPredPtrArry *pdrgpstatspredDisj = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspredDisj->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 1)));
	pdrgpstatspredDisj->Append(conjunctive_pred_stats);

	return GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
}

// create nested AND and OR predicates where the AND and OR predicates share common columns
CStatsPred *
CFilterCardinalityTest::PstatspredDisjOverConjSameCol2(CMemoryPool *mp)
{
	CStatsPredPtrArry *pdrgpstatspredConj = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	// predicate col_1 <= 5 AND col_1 >=1
	pdrgpstatspredConj->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptLEq, CTestUtils::PpointInt4(mp, 5)));
	pdrgpstatspredConj->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptGEq, CTestUtils::PpointInt4(mp, 1)));

	CStatsPredConj *conjunctive_pred_stats =
		GPOS_NEW(mp) CStatsPredConj(pdrgpstatspredConj);

	// predicate (col_1 = 1);
	CStatsPredPtrArry *pdrgpstatspredDisj = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspredDisj->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 1)));
	pdrgpstatspredDisj->Append(conjunctive_pred_stats);

	return GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
}

// create disjunctive predicate over conjunctions on same columns
CStatsPred *
CFilterCardinalityTest::PstatspredDisjOverConjSameCol3(CMemoryPool *mp)
{
	CStatsPredPtrArry *pdrgpstatspredDisj = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	CWStringDynamic *pstrS =
		GPOS_NEW(mp) CWStringDynamic(mp, GPOS_WSZ_LIT(""AAAABXM=""));
	CWStringDynamic *pstrW =
		GPOS_NEW(mp) CWStringDynamic(mp, GPOS_WSZ_LIT(""AAAABXc=""));

	// predicate is a == 's' AND b == 2001
	CStatsPredPtrArry *pdrgpstatspredConj1 = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspredConj1->Append(GPOS_NEW(mp) CStatsPredPoint(
		142, CStatsPred::EstatscmptEq,
		CCardinalityTestUtils::PpointGeneric(mp, GPDB_TEXT, pstrS, 160588332)));
	pdrgpstatspredConj1->Append(GPOS_NEW(mp) CStatsPredPoint(
		113, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 2001)));
	pdrgpstatspredDisj->Append(GPOS_NEW(mp)
								   CStatsPredConj(pdrgpstatspredConj1));

	// predicate is a == 's' AND b == 2002
	CStatsPredPtrArry *pdrgpstatspredConj2 = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspredConj2->Append(GPOS_NEW(mp) CStatsPredPoint(
		142, CStatsPred::EstatscmptEq,
		CCardinalityTestUtils::PpointGeneric(mp, GPDB_TEXT, pstrS, 160588332)));
	pdrgpstatspredConj2->Append(GPOS_NEW(mp) CStatsPredPoint(
		113, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 2002)));
	pdrgpstatspredDisj->Append(GPOS_NEW(mp)
								   CStatsPredConj(pdrgpstatspredConj2));

	// predicate is a == 'w' AND b == 2001
	CStatsPredPtrArry *pdrgpstatspredConj3 = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspredConj3->Append(GPOS_NEW(mp) CStatsPredPoint(
		142, CStatsPred::EstatscmptEq,
		CCardinalityTestUtils::PpointGeneric(mp, GPDB_TEXT, pstrW, 160621100)));
	pdrgpstatspredConj3->Append(GPOS_NEW(mp) CStatsPredPoint(
		113, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 2001)));
	pdrgpstatspredDisj->Append(GPOS_NEW(mp)
								   CStatsPredConj(pdrgpstatspredConj3));

	// predicate is a == 'w' AND b == 2002
	CStatsPredPtrArry *pdrgpstatspredConj4 = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspredConj4->Append(GPOS_NEW(mp) CStatsPredPoint(
		142, CStatsPred::EstatscmptEq,
		CCardinalityTestUtils::PpointGeneric(mp, GPDB_TEXT, pstrW, 160621100)));
	pdrgpstatspredConj4->Append(GPOS_NEW(mp) CStatsPredPoint(
		113, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 2002)));
	pdrgpstatspredDisj->Append(GPOS_NEW(mp)
								   CStatsPredConj(pdrgpstatspredConj4));

	GPOS_DELETE(pstrS);
	GPOS_DELETE(pstrW);

	return GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
}

// create disjunctive predicate over conjunctions on same columns
CStatsPred *
CFilterCardinalityTest::PstatspredDisjOverConjSameCol4(CMemoryPool *mp)
{
	CStatsPredPtrArry *pdrgpstatspredDisj = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	CWStringDynamic *pstrS =
		GPOS_NEW(mp) CWStringDynamic(mp, GPOS_WSZ_LIT(""AAAABXM=""));
	CWStringDynamic *pstrW =
		GPOS_NEW(mp) CWStringDynamic(mp, GPOS_WSZ_LIT(""AAAABXc=""));

	// predicate is a == 's' AND b == 2001 AND c > 0
	CStatsPredPtrArry *pdrgpstatspredConj1 = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspredConj1->Append(GPOS_NEW(mp) CStatsPredPoint(
		91, CStatsPred::EstatscmptEq,
		CCardinalityTestUtils::PpointGeneric(mp, GPDB_TEXT, pstrS, 160588332)));
	pdrgpstatspredConj1->Append(GPOS_NEW(mp) CStatsPredPoint(
		61, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 2001)));
	pdrgpstatspredConj1->Append(GPOS_NEW(mp) CStatsPredPoint(
		90, CStatsPred::EstatscmptG, CTestUtils::PpointInt4(mp, 0)));
	pdrgpstatspredDisj->Append(GPOS_NEW(mp)
								   CStatsPredConj(pdrgpstatspredConj1));

	// predicate is a == 's' AND b == 2002
	CStatsPredPtrArry *pdrgpstatspredConj2 = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspredConj2->Append(GPOS_NEW(mp) CStatsPredPoint(
		91, CStatsPred::EstatscmptEq,
		CCardinalityTestUtils::PpointGeneric(mp, GPDB_TEXT, pstrS, 160588332)));
	pdrgpstatspredConj2->Append(GPOS_NEW(mp) CStatsPredPoint(
		61, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 2002)));
	pdrgpstatspredDisj->Append(GPOS_NEW(mp)
								   CStatsPredConj(pdrgpstatspredConj2));

	// predicate is a == 'w' AND b == 2001 AND c > 0
	CStatsPredPtrArry *pdrgpstatspredConj3 = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspredConj3->Append(GPOS_NEW(mp) CStatsPredPoint(
		91, CStatsPred::EstatscmptEq,
		CCardinalityTestUtils::PpointGeneric(mp, GPDB_TEXT, pstrW, 160621100)));
	pdrgpstatspredConj3->Append(GPOS_NEW(mp) CStatsPredPoint(
		61, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 2001)));
	pdrgpstatspredConj1->Append(GPOS_NEW(mp) CStatsPredPoint(
		90, CStatsPred::EstatscmptG, CTestUtils::PpointInt4(mp, 0)));
	pdrgpstatspredDisj->Append(GPOS_NEW(mp)
								   CStatsPredConj(pdrgpstatspredConj3));

	// predicate is a == 'w' AND b == 2002
	CStatsPredPtrArry *pdrgpstatspredConj4 = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspredConj4->Append(GPOS_NEW(mp) CStatsPredPoint(
		91, CStatsPred::EstatscmptEq,
		CCardinalityTestUtils::PpointGeneric(mp, GPDB_TEXT, pstrW, 160621100)));
	pdrgpstatspredConj4->Append(GPOS_NEW(mp) CStatsPredPoint(
		61, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 2002)));
	pdrgpstatspredDisj->Append(GPOS_NEW(mp)
								   CStatsPredConj(pdrgpstatspredConj4));

	GPOS_DELETE(pstrS);
	GPOS_DELETE(pstrW);

	return GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
}

// create nested AND and OR predicates where the AND and OR predicates share common columns
CStatsPred *
CFilterCardinalityTest::PstatspredDisjOverConjDifferentCol1(CMemoryPool *mp)
{
	CStatsPredPtrArry *pdrgpstatspredConj = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	// predicate col_1 = 3 AND col_2 >=3
	pdrgpstatspredConj->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 3)));
	pdrgpstatspredConj->Append(GPOS_NEW(mp) CStatsPredPoint(
		2, CStatsPred::EstatscmptGEq, CTestUtils::PpointInt4(mp, 3)));

	CStatsPredConj *conjunctive_pred_stats =
		GPOS_NEW(mp) CStatsPredConj(pdrgpstatspredConj);

	// predicate (col_1 = 1);
	CStatsPredPtrArry *pdrgpstatspredDisj = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspredDisj->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 1)));
	pdrgpstatspredDisj->Append(conjunctive_pred_stats);

	return GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
}

// create nested AND and OR predicates where the AND and OR predicates
CStatsPred *
CFilterCardinalityTest::PstatspredDisjOverConjMultipleIdenticalCols(
	CMemoryPool *mp)
{
	CStatsPredPtrArry *pdrgpstatspredConj1 = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	// predicate col_1 = 1 AND col_2 = 1
	pdrgpstatspredConj1->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 1)));
	pdrgpstatspredConj1->Append(GPOS_NEW(mp) CStatsPredPoint(
		2, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 1)));

	CStatsPredConj *pstatspredConj1 =
		GPOS_NEW(mp) CStatsPredConj(pdrgpstatspredConj1);

	CStatsPredPtrArry *pdrgpstatspredConj2 = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	// predicate col_1 = 2 AND col_2 = 2
	pdrgpstatspredConj2->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 2)));
	pdrgpstatspredConj2->Append(GPOS_NEW(mp) CStatsPredPoint(
		2, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 2)));

	CStatsPredConj *pstatspredConj2 =
		GPOS_NEW(mp) CStatsPredConj(pdrgpstatspredConj2);
	CStatsPredPtrArry *pdrgpstatspredDisj = GPOS_NEW(mp) CStatsPredPtrArry(mp);

	pdrgpstatspredDisj->Append(pstatspredConj1);
	pdrgpstatspredDisj->Append(pstatspredConj2);

	return GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspredDisj);
}

// reads a DXL document, generates the statistics object, performs a
// filter operation on it, serializes it into a DXL document and
// compares the generated DXL document with the expected DXL document.
GPOS_RESULT
CFilterCardinalityTest::EresUnittest_CStatisticsBasicsFromDXLNumeric()
{
	// create memory pool
	CAutoMemoryPool amp;
	CMemoryPool *mp = amp.Pmp();

	SStatsCmpValElem rgStatsCmpValElem[] = {
		{CStatsPred::EstatscmptL, GPOS_WSZ_LIT(""AAAACgAAAgABAA==""),
		 CDouble(1.0)},
		{CStatsPred::EstatscmptLEq, GPOS_WSZ_LIT(""AAAACgAAAgABAA==""),
		 CDouble(1.0)},
		{CStatsPred::EstatscmptEq, GPOS_WSZ_LIT(""AAAACgAAAgABAA==""),
		 CDouble(1.0)},

		{CStatsPred::EstatscmptG, GPOS_WSZ_LIT(""AAAACgAAAgAyAA==""),
		 CDouble(50.0)},
		{CStatsPred::EstatscmptGEq, GPOS_WSZ_LIT(""AAAACgAAAgAyAA==""),
		 CDouble(50.0)},
		{CStatsPred::EstatscmptEq, GPOS_WSZ_LIT(""AAAACgAAAgAyAA==""),
		 CDouble(50.0)},

		{CStatsPred::EstatscmptL, GPOS_WSZ_LIT(""AAAACgAAAgABAA==""),
		 CDouble(1.0)},
		{CStatsPred::EstatscmptLEq, GPOS_WSZ_LIT(""AAAACgAAAgABAA==""),
		 CDouble(1.0)},
		{CStatsPred::EstatscmptEq, GPOS_WSZ_LIT(""AAAACgAAAgABAA==""),
		 CDouble(1.0)},
		{CStatsPred::EstatscmptG, GPOS_WSZ_LIT(""AAAACgAAAgABAA==""),
		 CDouble(1.0)},
		{CStatsPred::EstatscmptGEq, GPOS_WSZ_LIT(""AAAACgAAAgABAA==""),
		 CDouble(1.0)},

		{CStatsPred::EstatscmptL, GPOS_WSZ_LIT(""AAAACgAAAgAyAA==""),
		 CDouble(50.0)},
		{CStatsPred::EstatscmptLEq, GPOS_WSZ_LIT(""AAAACgAAAgAyAA==""),
		 CDouble(50.0)},
		{CStatsPred::EstatscmptG, GPOS_WSZ_LIT(""AAAACgAAAgAyAA==""),
		 CDouble(50.0)},
		{CStatsPred::EstatscmptGEq, GPOS_WSZ_LIT(""AAAACgAAAgAyAA==""),
		 CDouble(50.0)},
		{CStatsPred::EstatscmptEq, GPOS_WSZ_LIT(""AAAACgAAAgAyAA==""),
		 CDouble(50.0)},
	};

	const ULONG length = GPOS_ARRAY_SIZE(rgStatsCmpValElem);
	GPOS_ASSERT(length == GPOS_ARRAY_SIZE(rgtcStatistics));
	for (ULONG ul = 0; ul < length; ul++)
	{
		// read input DXL file
		CHAR *szDXLInput = CDXLUtils::Read(mp, rgtcStatistics[ul].szInputFile);
		// read output DXL file
		CHAR *szDXLOutput =
			CDXLUtils::Read(mp, rgtcStatistics[ul].szOutputFile);

		GPOS_CHECK_ABORT;

		CMDAccessor *md_accessor = COptCtxt::PoctxtFromTLS()->Pmda();
		// parse the statistics objects
		CDXLStatsDerivedRelationArray *dxl_derived_rel_stats_array =
			CDXLUtils::ParseDXLToStatsDerivedRelArray(mp, szDXLInput, NULL);
		CStatisticsArray *pdrgpstatBefore =
			CDXLUtils::ParseDXLToOptimizerStatisticObjArray(
				mp, md_accessor, dxl_derived_rel_stats_array);
		dxl_derived_rel_stats_array->Release();

		GPOS_ASSERT(NULL != pdrgpstatBefore);

		GPOS_CHECK_ABORT;

		SStatsCmpValElem statsCmpValElem = rgStatsCmpValElem[ul];

		CStatsPredPtrArry *pdrgpstatspred =
			PdrgppredfilterNumeric(mp, 1 /*colid*/, statsCmpValElem);
		CStatsPredConj *pred_stats =
			GPOS_NEW(mp) CStatsPredConj(pdrgpstatspred);
		GPOS_RESULT eres = EresUnittest_CStatisticsCompare(
			mp, md_accessor, pdrgpstatBefore, pred_stats, szDXLOutput,
			true /*fApplyTwice*/
		);

		// clean up
		pdrgpstatBefore->Release();
		pred_stats->Release();
		GPOS_DELETE_ARRAY(szDXLInput);
		GPOS_DELETE_ARRAY(szDXLOutput);

		if (GPOS_OK != eres)
		{
			return eres;
		}
	}

	return GPOS_OK;
}

// generate an array of filter given a column identifier, comparison type,
// and array of integer point
CStatsPredPtrArry *
CFilterCardinalityTest::PdrgpstatspredInteger(
	CMemoryPool *mp, ULONG colid, CStatsPred::EStatsCmpType stats_cmp_type,
	INT *piVals, ULONG ulVals)
{
	GPOS_ASSERT(0 < ulVals);

	CStatsPredPtrArry *pdrgpstatspred = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	for (ULONG ul = 0; ul < ulVals; ul++)
	{
		pdrgpstatspred->Append(GPOS_NEW(mp) CStatsPredPoint(
			colid, stats_cmp_type, CTestUtils::PpointInt4(mp, piVals[ul])));
	}

	return pdrgpstatspred;
}

// generate a numeric filter on the column specified and the literal value
CStatsPredPtrArry *
CFilterCardinalityTest::PdrgppredfilterNumeric(CMemoryPool *mp, ULONG colid,
											   SStatsCmpValElem statsCmpValElem)
{
	// create a filter
	CStatsPredPtrArry *pdrgpstatspred = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	CWStringDynamic *pstrNumeric =
		GPOS_NEW(mp) CWStringDynamic(mp, statsCmpValElem.m_wsz);
	CStatsPredPoint *pred_stats = GPOS_NEW(mp)
		CStatsPredPoint(colid, statsCmpValElem.m_stats_cmp_type,
						CCardinalityTestUtils::PpointNumeric(
							mp, pstrNumeric, statsCmpValElem.m_value));
	pdrgpstatspred->Append(pred_stats);
	GPOS_DELETE(pstrNumeric);

	return pdrgpstatspred;
}

// reads a DXL document, generates the statistics object, performs a
// filter operation on it, serializes it into a DXL document and
// compares the generated DXL document with the expected DXL document.
GPOS_RESULT
CFilterCardinalityTest::EresUnittest_CStatisticsBasicsFromDXL()
{
	// create memory pool
	CAutoMemoryPool amp;
	CMemoryPool *mp = amp.Pmp();

	CWStringDynamic str(mp);
	COstreamString oss(&str);

	// read input DXL file
	CHAR *szDXLInput = CDXLUtils::Read(mp, szInputDXLFileName);
	// read output DXL file
	CHAR *szDXLOutput = CDXLUtils::Read(mp, szOutputDXLFileName);

	GPOS_CHECK_ABORT;

	CMDAccessor *md_accessor = COptCtxt::PoctxtFromTLS()->Pmda();

	// parse the statistics objects
	CDXLStatsDerivedRelationArray *dxl_derived_rel_stats_array =
		CDXLUtils::ParseDXLToStatsDerivedRelArray(mp, szDXLInput, NULL);
	CStatisticsArray *pdrgpstatsBefore =
		CDXLUtils::ParseDXLToOptimizerStatisticObjArray(
			mp, md_accessor, dxl_derived_rel_stats_array);
	dxl_derived_rel_stats_array->Release();
	GPOS_ASSERT(NULL != pdrgpstatsBefore);

	GPOS_CHECK_ABORT;

	// create a filter
	CStatsPredConj *pred_stats =
		GPOS_NEW(mp) CStatsPredConj(CStatisticsTest::Pdrgpstatspred2(mp));
	GPOS_RESULT eres = EresUnittest_CStatisticsCompare(
		mp, md_accessor, pdrgpstatsBefore, pred_stats, szDXLOutput);

	// clean up
	pdrgpstatsBefore->Release();
	pred_stats->Release();
	GPOS_DELETE_ARRAY(szDXLInput);
	GPOS_DELETE_ARRAY(szDXLOutput);

	return eres;
}

// performs a filter operation on it, serializes it into a DXL document
// and compares the generated DXL document with the expected DXL document
GPOS_RESULT
CFilterCardinalityTest::EresUnittest_CStatisticsCompare(
	CMemoryPool *mp, CMDAccessor *md_accessor,
	CStatisticsArray *pdrgpstatBefore, CStatsPred *pred_stats,
	const CHAR *szDXLOutput, BOOL fApplyTwice)
{
	CWStringDynamic str(mp);
	COstreamString oss(&str);

	CStatistics *input_stats = (*pdrgpstatBefore)[0];

	GPOS_TRACE(GPOS_WSZ_LIT(""Statistics before""));
	CCardinalityTestUtils::PrintStats(mp, input_stats);

	CStatistics *pstatsOutput = CFilterStatsProcessor::MakeStatsFilter(
		mp, input_stats, pred_stats, true /* do_cap_NDVs */);

	GPOS_TRACE(GPOS_WSZ_LIT(""Statistics after""));
	CCardinalityTestUtils::PrintStats(mp, pstatsOutput);

	// output array of stats objects
	CStatisticsArray *pdrgpstatOutput = GPOS_NEW(mp) CStatisticsArray(mp);
	pdrgpstatOutput->Append(pstatsOutput);

	oss << ""Serializing Input Statistics Objects (Before Filter)"" << std::endl;
	CWStringDynamic *pstrInput = CDXLUtils::SerializeStatistics(
		mp, md_accessor, pdrgpstatBefore, true /*serialize_header_footer*/,
		true /*indentation*/
	);
	GPOS_TRACE(pstrInput->GetBuffer());
	GPOS_DELETE(pstrInput);

	oss << ""Serializing Output Statistics Objects (After Filter)"" << std::endl;
	CWStringDynamic *pstrOutput = CDXLUtils::SerializeStatistics(
		mp, md_accessor, pdrgpstatOutput, true /*serialize_header_footer*/,
		true /*indentation*/
	);
	GPOS_TRACE(pstrOutput->GetBuffer());

	CWStringDynamic dstrExpected(mp);
	dstrExpected.AppendFormat(GPOS_WSZ_LIT(""%s""), szDXLOutput);

	GPOS_RESULT eres = CTestUtils::EresCompare(
		oss, pstrOutput, &dstrExpected, false /* ignore mismatch */
	);

	if (fApplyTwice && GPOS_OK == eres)
	{
		CStatistics *pstatsOutput2 = CFilterStatsProcessor::MakeStatsFilter(
			mp, pstatsOutput, pred_stats, true /* do_cap_NDVs */);
		pstatsOutput2->Rows();
		GPOS_TRACE(GPOS_WSZ_LIT(""Statistics after another filter""));
		CCardinalityTestUtils::PrintStats(mp, pstatsOutput2);

		// output array of stats objects
		CStatisticsArray *pdrgpstatOutput2 = GPOS_NEW(mp) CStatisticsArray(mp);
		pdrgpstatOutput2->Append(pstatsOutput2);

		CWStringDynamic *pstrOutput2 = CDXLUtils::SerializeStatistics(
			mp, md_accessor, pdrgpstatOutput2, true /*serialize_header_footer*/,
			true /*indentation*/
		);
		eres = CTestUtils::EresCompare(
			oss, pstrOutput2, &dstrExpected, false /* ignore mismatch */
		);

		pdrgpstatOutput2->Release();
		GPOS_DELETE(pstrOutput2);
	}

	pdrgpstatOutput->Release();
	GPOS_DELETE(pstrOutput);

	return eres;
}

// test for accumulating cardinality in disjunctive and conjunctive predicates
GPOS_RESULT
CFilterCardinalityTest::EresUnittest_CStatisticsAccumulateCard()
{
	// create memory pool
	CAutoMemoryPool amp;
	CMemoryPool *mp = amp.Pmp();

	// create hash map from colid -> histogram
	UlongToHistogramMap *col_histogram_mapping =
		GPOS_NEW(mp) UlongToHistogramMap(mp);

	// array capturing columns for which width information is available
	UlongToDoubleMap *colid_width_mapping = GPOS_NEW(mp) UlongToDoubleMap(mp);

	const ULONG num_cols = 3;
	for (ULONG ul = 0; ul < num_cols; ul++)
	{
		// generate histogram of the form [0, 10), [10, 20), [20, 30), [80, 90), [100,100]
		col_histogram_mapping->Insert(
			GPOS_NEW(mp) ULONG(ul),
			CCardinalityTestUtils::PhistExampleInt4(mp));

		// width for int
		colid_width_mapping->Insert(GPOS_NEW(mp) ULONG(ul),
									GPOS_NEW(mp) CDouble(4.0));
	}

	CStatistics *stats = GPOS_NEW(mp)
		CStatistics(mp, col_histogram_mapping, colid_width_mapping,
					CDouble(1000.0) /* rows */, false /* is_empty() */
		);
	GPOS_TRACE(GPOS_WSZ_LIT(""\\nOriginal Stats:\\n""));
	CCardinalityTestUtils::PrintStats(mp, stats);

	// (1)
	// create disjunctive filter
	CStatsPredPtrArry *pdrgpstatspred = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspred->Append(GPOS_NEW(mp) CStatsPredPoint(
		0, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 5)));
	pdrgpstatspred->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 200)));
	pdrgpstatspred->Append(GPOS_NEW(mp) CStatsPredPoint(
		2, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 200)));
	CStatsPredDisj *disjunctive_pred_stats =
		GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspred);

	// apply filter and print resulting stats
	CStatistics *pstats1 = CFilterStatsProcessor::MakeStatsFilter(
		mp, stats, disjunctive_pred_stats, true /* do_cap_NDVs */);
	CDouble num_rows1 = pstats1->Rows();
	GPOS_TRACE(GPOS_WSZ_LIT(
		""\\n\\nStats after disjunctive filter [Col0=5 OR Col1=200 OR Col2=200]:\\n""));
	CCardinalityTestUtils::PrintStats(mp, pstats1);

	disjunctive_pred_stats->Release();

	// (2)
	// create point filter
	CStatsPredPtrArry *pdrgpstatspred1 = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspred1->Append(GPOS_NEW(mp) CStatsPredPoint(
		0, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 5)));
	CStatsPredConj *pstatspredConj1 =
		GPOS_NEW(mp) CStatsPredConj(pdrgpstatspred1);

	// apply filter and print resulting stats
	CStatistics *pstats2 = CFilterStatsProcessor::MakeStatsFilter(
		mp, stats, pstatspredConj1, true /* do_cap_NDVs */);
	CDouble num_rows2 = pstats2->Rows();
	GPOS_TRACE(GPOS_WSZ_LIT(""\\n\\nStats after point filter [Col0=5]:\\n""));
	CCardinalityTestUtils::PrintStats(mp, pstats2);

	pstatspredConj1->Release();

	GPOS_RTL_ASSERT(
		num_rows1 - num_rows2 < 10 &&
		""Disjunctive filter and point filter have very different row estimates"");

	// (3)
	// create conjunctive filter
	CStatsPredPtrArry *pdrgpstatspred2 = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspred2->Append(GPOS_NEW(mp) CStatsPredPoint(
		0, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 5)));
	pdrgpstatspred2->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 200)));
	pdrgpstatspred2->Append(GPOS_NEW(mp) CStatsPredPoint(
		2, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 200)));

	CStatsPredConj *pstatspredConj2 =
		GPOS_NEW(mp) CStatsPredConj(pdrgpstatspred2);

	// apply filter and print resulting stats
	CStatistics *pstats3 = CFilterStatsProcessor::MakeStatsFilter(
		mp, stats, pstatspredConj2, true /* do_cap_NDVs */);
	CDouble dRows3 = pstats3->Rows();
	GPOS_TRACE(GPOS_WSZ_LIT(
		""\\n\\nStats after conjunctive filter [Col0=5 AND Col1=200 AND Col2=200]:\\n""));
	CCardinalityTestUtils::PrintStats(mp, pstats3);

	pstatspredConj2->Release();
	GPOS_RTL_ASSERT(
		dRows3 < num_rows2 &&
		""Conjunctive filter passes more rows than than point filter"");

	// (4)
	// create selective disjunctive filter that pass no rows
	CStatsPredPtrArry *pdrgpstatspred3 = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspred3->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 200)));
	pdrgpstatspred3->Append(GPOS_NEW(mp) CStatsPredPoint(
		2, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 200)));
	CStatsPredDisj *pstatspredDisj1 =
		GPOS_NEW(mp) CStatsPredDisj(pdrgpstatspred3);

	// apply filter and print resulting stats
	CStatistics *pstats4 = CFilterStatsProcessor::MakeStatsFilter(
		mp, stats, pstatspredDisj1, true /* do_cap_NDVs */);
	CDouble dRows4 = pstats4->Rows();
	GPOS_TRACE(GPOS_WSZ_LIT(
		""\\n\\nStats after disjunctive filter [Col1=200 OR Col2=200]:\\n""));
	CCardinalityTestUtils::PrintStats(mp, pstats4);

	pstatspredDisj1->Release();

	GPOS_RTL_ASSERT(
		dRows4 < num_rows2 &&
		""Selective disjunctive filter passes more rows than than point filter"");

	// (5)
	// create selective conjunctive filter that pass no rows
	CStatsPredPtrArry *pdrgpstatspred4 = GPOS_NEW(mp) CStatsPredPtrArry(mp);
	pdrgpstatspred4->Append(GPOS_NEW(mp) CStatsPredPoint(
		0, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 5)));
	pdrgpstatspred4->Append(GPOS_NEW(mp) CStatsPredPoint(
		1, CStatsPred::EstatscmptEq, CTestUtils::PpointInt4(mp, 200)));
	CStatsPredConj *pstatspredConj3 =
		GPOS_NEW(mp) CStatsPredConj(pdrgpstatspred4);

	// apply filter and print resulting stats
	CStatistics *pstats5 = CFilterStatsProcessor::MakeStatsFilter(
		mp, stats, pstatspredConj3, true /* do_cap_NDVs */);
	CDouble dRows5 = pstats5->Rows();
	GPOS_TRACE(GPOS_WSZ_LIT(
		""\\n\\nStats after conjunctive filter [Col0=5 AND Col1=200]:\\n""));
	CCardinalityTestUtils::PrintStats(mp, pstats5);

	pstatspredConj3->Release();

	GPOS_RTL_ASSERT(
		dRows5 < num_rows2 &&
		""Selective conjunctive filter passes more rows than than point filter"");

	// clean up
	stats->Release();
	pstats1->Release();
	pstats2->Release();
	pstats3->Release();
	pstats4->Release();
	pstats5->Release();

	return GPOS_OK;
}

// EOF
",16196,True,3838.057422740479,median
"[.configuration-legend]
icon:lock[title=Fixed at build time] Configuration property fixed at build time - All other configuration properties are overridable at runtime
[.configuration-reference, cols=""80,.^10,.^10""]
|===

h|[[quarkus-oidc-oidc-config_configuration]]link:#quarkus-oidc-oidc-config_configuration[Configuration property]

h|Type
h|Default

a| [[quarkus-oidc-oidc-config_quarkus.oidc.tenant-id]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.tenant-id[quarkus.oidc.tenant-id]`

[.description]
--
A unique tenant identifier. It must be set by `TenantConfigResolver` providers which resolve the tenant configuration dynamically and is optional in all other cases.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.tenant-enabled]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.tenant-enabled[quarkus.oidc.tenant-enabled]`

[.description]
--
If this tenant configuration is enabled.
--|boolean 
|`true`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.application-type]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.application-type[quarkus.oidc.application-type]`

[.description]
--
The application type, which can be one of the following values from enum `ApplicationType`.
--|`web-app`, `service` 
|`service`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.auth-server-url]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.auth-server-url[quarkus.oidc.auth-server-url]`

[.description]
--
The base URL of the OpenID Connect (OIDC) server, for example, 'https://host:port/auth'. OIDC discovery endpoint will be called by default by appending a '.well-known/openid-configuration' path to this URL. Note if you work with Keycloak OIDC server, make sure the base URL is in the following format: 'https://host:port/auth/realms/++{++realm++}++' where '++{++realm++}++' has to be replaced by the name of the Keycloak realm.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.discovery-enabled]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.discovery-enabled[quarkus.oidc.discovery-enabled]`

[.description]
--
Enables OIDC discovery. If the discovery is disabled then the following properties must be configured: - 'authorization-path' and 'token-path' for the 'web-app' applications - 'jwks-path' or 'introspection-path' for both the 'web-app' and 'service' applications 
 'web-app' applications may also have 'user-info-path' and 'end-session-path' properties configured.
--|boolean 
|`true`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.authorization-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.authorization-path[quarkus.oidc.authorization-path]`

[.description]
--
Relative path of the OIDC authorization endpoint which authenticates the users. This property must be set for the 'web-app' applications if OIDC discovery is disabled. This property will be ignored if the discovery is enabled.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.token-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.token-path[quarkus.oidc.token-path]`

[.description]
--
Relative path of the OIDC token endpoint which issues ID, access and refresh tokens. This property must be set for the 'web-app' applications if OIDC discovery is disabled. This property will be ignored if the discovery is enabled.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.user-info-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.user-info-path[quarkus.oidc.user-info-path]`

[.description]
--
Relative path of the OIDC userinfo endpoint. This property must only be set for the 'web-app' applications if OIDC discovery is disabled and 'authentication.user-info-required' property is enabled. This property will be ignored if the discovery is enabled.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.introspection-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.introspection-path[quarkus.oidc.introspection-path]`

[.description]
--
Relative path of the OIDC RFC7662 introspection endpoint which can introspect both opaque and JWT tokens. This property must be set if OIDC discovery is disabled and 1) the opaque bearer access tokens have to be verified or 2) JWT tokens have to be verified while the cached JWK verification set with no matching JWK is being refreshed. This property will be ignored if the discovery is enabled.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.jwks-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.jwks-path[quarkus.oidc.jwks-path]`

[.description]
--
Relative path of the OIDC JWKS endpoint which returns a JSON Web Key Verification Set. This property should be set if OIDC discovery is disabled and the local JWT verification is required. This property will be ignored if the discovery is enabled.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.end-session-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.end-session-path[quarkus.oidc.end-session-path]`

[.description]
--
Relative path of the OIDC end_session_endpoint. This property must be set if OIDC discovery is disabled and RP Initiated Logout support for the 'web-app' applications is required. This property will be ignored if the discovery is enabled.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.connection-delay]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.connection-delay[quarkus.oidc.connection-delay]`

[.description]
--
The maximum amount of time the adapter will try connecting to the currently unavailable OIDC server for. For example, setting it to '20S' will let the adapter keep requesting the connection for up to 20 seconds.
--|link:https://docs.oracle.com/javase/8/docs/api/java/time/Duration.html[Duration]
  link:#duration-note-anchor[icon:question-circle[], title=More information about the Duration format]
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.public-key]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.public-key[quarkus.oidc.public-key]`

[.description]
--
Public key for the local JWT token verification. OIDC server connection will not be created when this property is set.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.client-id]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.client-id[quarkus.oidc.client-id]`

[.description]
--
The client-id of the application. Each application has a client-id that is used to identify the application
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.roles.role-claim-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.roles.role-claim-path[quarkus.oidc.roles.role-claim-path]`

[.description]
--
Path to the claim containing an array of groups. It starts from the top level JWT JSON object and can contain multiple segments where each segment represents a JSON object name only, example: ""realm/groups"". Use double quotes with the namespace qualified claim names. This property can be used if a token has no 'groups' claim but has the groups set in a different claim.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.roles.role-claim-separator]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.roles.role-claim-separator[quarkus.oidc.roles.role-claim-separator]`

[.description]
--
Separator for splitting a string which may contain multiple group values. It will only be used if the ""role-claim-path"" property points to a custom claim whose value is a string. A single space will be used by default because the standard 'scope' claim may contain a space separated sequence.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.roles.source]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.roles.source[quarkus.oidc.roles.source]`

[.description]
--
Source of the principal roles.
--|`idtoken`, `accesstoken`, `userinfo` 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.token.issuer]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.token.issuer[quarkus.oidc.token.issuer]`

[.description]
--
Expected issuer 'iss' claim value.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.token.audience]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.token.audience[quarkus.oidc.token.audience]`

[.description]
--
Expected audience 'aud' claim value which may be a string or an array of strings.
--|list of string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.token.token-type]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.token.token-type[quarkus.oidc.token.token-type]`

[.description]
--
Expected token type
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.token.lifespan-grace]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.token.lifespan-grace[quarkus.oidc.token.lifespan-grace]`

[.description]
--
Life span grace period in seconds. When checking token expiry, current time is allowed to be later than token expiration time by at most the configured number of seconds. When checking token issuance, current time is allowed to be sooner than token issue time by at most the configured number of seconds.
--|int 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.token.principal-claim]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.token.principal-claim[quarkus.oidc.token.principal-claim]`

[.description]
--
Name of the claim which contains a principal name. By default, the 'upn', 'preferred_username' and `sub` claims are checked.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.token.refresh-expired]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.token.refresh-expired[quarkus.oidc.token.refresh-expired]`

[.description]
--
Refresh expired ID tokens. If this property is enabled then a refresh token request will be performed if the ID token has expired and, if successful, the local session will be updated with the new set of tokens. Otherwise, the local session will be invalidated and the user redirected to the OpenID Provider to re-authenticate. In this case the user may not be challenged again if the OIDC provider session is still active. For this option be effective the `authentication.session-age-extension` property should also be set to a non-zero value since the refresh token is currently kept in the user session. This option is valid only when the application is of type `ApplicationType++#++WEB_APP`++}++.
--|boolean 
|`false`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.token.auto-refresh-interval]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.token.auto-refresh-interval[quarkus.oidc.token.auto-refresh-interval]`

[.description]
--
Token auto-refresh interval in seconds during the user re-authentication. If this option is set then the valid ID token will be refreshed if it will expire in less than a number of minutes set by this option. The user will still be authenticated if the ID token can no longer be refreshed but is still valid. This option will be ignored if the 'refresh-expired' property is not enabled.
--|link:https://docs.oracle.com/javase/8/docs/api/java/time/Duration.html[Duration]
  link:#duration-note-anchor[icon:question-circle[], title=More information about the Duration format]
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.token.forced-jwk-refresh-interval]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.token.forced-jwk-refresh-interval[quarkus.oidc.token.forced-jwk-refresh-interval]`

[.description]
--
Forced JWK set refresh interval in minutes.
--|link:https://docs.oracle.com/javase/8/docs/api/java/time/Duration.html[Duration]
  link:#duration-note-anchor[icon:question-circle[], title=More information about the Duration format]
|`10M`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.credentials.secret]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.credentials.secret[quarkus.oidc.credentials.secret]`

[.description]
--
Client secret which is used for a 'client_secret_basic' authentication method. Note that a 'client-secret.value' can be used instead but both properties are mutually exclusive.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.credentials.client-secret.value]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.credentials.client-secret.value[quarkus.oidc.credentials.client-secret.value]`

[.description]
--
The client secret
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.credentials.client-secret.method]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.credentials.client-secret.method[quarkus.oidc.credentials.client-secret.method]`

[.description]
--
Authentication method.
--|`basic`, `post` 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.credentials.jwt.secret]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.credentials.jwt.secret[quarkus.oidc.credentials.jwt.secret]`

[.description]
--
client_secret_jwt: JWT which includes client id as one of its claims is signed by the client secret and is submitted as a 'client_assertion' form parameter, while 'client_assertion_type' parameter is set to ""urn:ietf:params:oauth:client-assertion-type:jwt-bearer"".
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.credentials.jwt.lifespan]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.credentials.jwt.lifespan[quarkus.oidc.credentials.jwt.lifespan]`

[.description]
--
JWT life-span in seconds. It will be added to the time it was issued at to calculate the expiration time.
--|int 
|`10`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.proxy.host]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.proxy.host[quarkus.oidc.proxy.host]`

[.description]
--
The host (name or IP address) of the Proxy.
 Note: If OIDC adapter needs to use a Proxy to talk with OIDC server (Provider), then at least the ""host"" config item must be configured to enable the usage of a Proxy.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.proxy.port]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.proxy.port[quarkus.oidc.proxy.port]`

[.description]
--
The port number of the Proxy. Default value is 80.
--|int 
|`80`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.proxy.username]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.proxy.username[quarkus.oidc.proxy.username]`

[.description]
--
The username, if Proxy needs authentication.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.proxy.password]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.proxy.password[quarkus.oidc.proxy.password]`

[.description]
--
The password, if Proxy needs authentication.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.authentication.redirect-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.authentication.redirect-path[quarkus.oidc.authentication.redirect-path]`

[.description]
--
Relative path for calculating a ""redirect_uri"" query parameter. It has to start from a forward slash and will be appended to the request URI's host and port. For example, if the current request URI is 'https://localhost:8080/service' then a 'redirect_uri' parameter will be set to 'https://localhost:8080/' if this property is set to '/' and be the same as the request URI if this property has not been configured. Note the original request URI will be restored after the user has authenticated.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.authentication.restore-path-after-redirect]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.authentication.restore-path-after-redirect[quarkus.oidc.authentication.restore-path-after-redirect]`

[.description]
--
If this property is set to 'true' then the original request URI which was used before the authentication will be restored after the user has been redirected back to the application.
--|boolean 
|`true`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.authentication.remove-redirect-parameters]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.authentication.remove-redirect-parameters[quarkus.oidc.authentication.remove-redirect-parameters]`

[.description]
--
Remove the query parameters such as 'code' and 'state' set by the OIDC server on the redirect URI after the user has authenticated by redirecting a user to the same URI but without the query parameters.
--|boolean 
|`true`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.authentication.verify-access-token]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.authentication.verify-access-token[quarkus.oidc.authentication.verify-access-token]`

[.description]
--
Both ID and access tokens are fetched from the OIDC provider as part of the authorization code flow. ID token is always verified on every user request as the primary token which is used to represent the principal and extract the roles. Access token is not verified by default since it is meant to be propagated to the downstream services. The verification of the access token should be enabled if it is injected as a JWT token. Access tokens obtained as part of the code flow will always be verified if `quarkus.oidc.roles.source` property is set to `accesstoken` which means the authorization decision will be based on the roles extracted from the access token. Bearer access tokens are always verified.
--|boolean 
|`false`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.authentication.force-redirect-https-scheme]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.authentication.force-redirect-https-scheme[quarkus.oidc.authentication.force-redirect-https-scheme]`

[.description]
--
Force 'https' as the 'redirect_uri' parameter scheme when running behind an SSL terminating reverse proxy. This property, if enabled, will also affect the logout `post_logout_redirect_uri` and the local redirect requests.
--|boolean 
|`false`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.authentication.scopes]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.authentication.scopes[quarkus.oidc.authentication.scopes]`

[.description]
--
List of scopes
--|list of string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.authentication.cookie-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.authentication.cookie-path[quarkus.oidc.authentication.cookie-path]`

[.description]
--
Cookie path parameter value which, if set, will be used for the session, state and post logout cookies. It may need to be set when the redirect path has a root different to that of the original request URL.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.authentication.cookie-domain]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.authentication.cookie-domain[quarkus.oidc.authentication.cookie-domain]`

[.description]
--
Cookie domain parameter value which, if set, will be used for the session, state and post logout cookies.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.authentication.user-info-required]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.authentication.user-info-required[quarkus.oidc.authentication.user-info-required]`

[.description]
--
If this property is set to 'true' then an OIDC UserInfo endpoint will be called
--|boolean 
|`false`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.authentication.session-age-extension]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.authentication.session-age-extension[quarkus.oidc.authentication.session-age-extension]`

[.description]
--
Session age extension in minutes. The user session age property is set to the value of the ID token life-span by default and the user will be redirected to the OIDC provider to re-authenticate once the session has expired. If this property is set to a non-zero value then the expired ID token can be refreshed before the session has expired. This property will be ignored if the `token.refresh-expired` property has not been enabled.
--|link:https://docs.oracle.com/javase/8/docs/api/java/time/Duration.html[Duration]
  link:#duration-note-anchor[icon:question-circle[], title=More information about the Duration format]
|`5M`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.authentication.xhr-auto-redirect]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.authentication.xhr-auto-redirect[quarkus.oidc.authentication.xhr-auto-redirect]`

[.description]
--
If this property is set to 'true' then a normal 302 redirect response will be returned if the request was initiated via XMLHttpRequest and the current user needs to be (re)authenticated which may not be desirable for Single Page Applications since XMLHttpRequest automatically following the redirect may not work given that OIDC authorization endpoints typically do not support CORS. If this property is set to `false` then a status code of '499' will be returned to allow the client to handle the redirect manually
--|boolean 
|`true`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.tls.verification]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.tls.verification[quarkus.oidc.tls.verification]`

[.description]
--
Certificate validation and hostname verification, which can be one of the following values from enum `Verification`. Default is required.
--|`required`, `none` 
|`required`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.logout.path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.logout.path[quarkus.oidc.logout.path]`

[.description]
--
The relative path of the logout endpoint at the application. If provided, the application is able to initiate the logout through this endpoint in conformance with the OpenID Connect RP-Initiated Logout specification.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.logout.post-logout-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.logout.post-logout-path[quarkus.oidc.logout.post-logout-path]`

[.description]
--
Relative path of the application endpoint where the user should be redirected to after logging out from the OpenID Connect Provider. This endpoint URI must be properly registered at the OpenID Connect Provider as a valid redirect URI.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.authentication.extra-params-extra-params]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.authentication.extra-params-extra-params[quarkus.oidc.authentication.extra-params]`

[.description]
--
Additional properties which will be added as the query parameters to the authentication redirect URI.
--|`Map<String,String>` 
|


h|[[quarkus-oidc-oidc-config_quarkus.oidc.named-tenants-additional-named-tenants]]link:#quarkus-oidc-oidc-config_quarkus.oidc.named-tenants-additional-named-tenants[Additional named tenants]

h|Type
h|Default

a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.tenant-id]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.tenant-id[quarkus.oidc.""tenant"".tenant-id]`

[.description]
--
A unique tenant identifier. It must be set by `TenantConfigResolver` providers which resolve the tenant configuration dynamically and is optional in all other cases.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.tenant-enabled]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.tenant-enabled[quarkus.oidc.""tenant"".tenant-enabled]`

[.description]
--
If this tenant configuration is enabled.
--|boolean 
|`true`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.application-type]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.application-type[quarkus.oidc.""tenant"".application-type]`

[.description]
--
The application type, which can be one of the following values from enum `ApplicationType`.
--|`web-app`, `service` 
|`service`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.auth-server-url]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.auth-server-url[quarkus.oidc.""tenant"".auth-server-url]`

[.description]
--
The base URL of the OpenID Connect (OIDC) server, for example, 'https://host:port/auth'. OIDC discovery endpoint will be called by default by appending a '.well-known/openid-configuration' path to this URL. Note if you work with Keycloak OIDC server, make sure the base URL is in the following format: 'https://host:port/auth/realms/++{++realm++}++' where '++{++realm++}++' has to be replaced by the name of the Keycloak realm.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.discovery-enabled]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.discovery-enabled[quarkus.oidc.""tenant"".discovery-enabled]`

[.description]
--
Enables OIDC discovery. If the discovery is disabled then the following properties must be configured: - 'authorization-path' and 'token-path' for the 'web-app' applications - 'jwks-path' or 'introspection-path' for both the 'web-app' and 'service' applications 
 'web-app' applications may also have 'user-info-path' and 'end-session-path' properties configured.
--|boolean 
|`true`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authorization-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authorization-path[quarkus.oidc.""tenant"".authorization-path]`

[.description]
--
Relative path of the OIDC authorization endpoint which authenticates the users. This property must be set for the 'web-app' applications if OIDC discovery is disabled. This property will be ignored if the discovery is enabled.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token-path[quarkus.oidc.""tenant"".token-path]`

[.description]
--
Relative path of the OIDC token endpoint which issues ID, access and refresh tokens. This property must be set for the 'web-app' applications if OIDC discovery is disabled. This property will be ignored if the discovery is enabled.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.user-info-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.user-info-path[quarkus.oidc.""tenant"".user-info-path]`

[.description]
--
Relative path of the OIDC userinfo endpoint. This property must only be set for the 'web-app' applications if OIDC discovery is disabled and 'authentication.user-info-required' property is enabled. This property will be ignored if the discovery is enabled.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.introspection-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.introspection-path[quarkus.oidc.""tenant"".introspection-path]`

[.description]
--
Relative path of the OIDC RFC7662 introspection endpoint which can introspect both opaque and JWT tokens. This property must be set if OIDC discovery is disabled and 1) the opaque bearer access tokens have to be verified or 2) JWT tokens have to be verified while the cached JWK verification set with no matching JWK is being refreshed. This property will be ignored if the discovery is enabled.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.jwks-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.jwks-path[quarkus.oidc.""tenant"".jwks-path]`

[.description]
--
Relative path of the OIDC JWKS endpoint which returns a JSON Web Key Verification Set. This property should be set if OIDC discovery is disabled and the local JWT verification is required. This property will be ignored if the discovery is enabled.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.end-session-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.end-session-path[quarkus.oidc.""tenant"".end-session-path]`

[.description]
--
Relative path of the OIDC end_session_endpoint. This property must be set if OIDC discovery is disabled and RP Initiated Logout support for the 'web-app' applications is required. This property will be ignored if the discovery is enabled.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.connection-delay]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.connection-delay[quarkus.oidc.""tenant"".connection-delay]`

[.description]
--
The maximum amount of time the adapter will try connecting to the currently unavailable OIDC server for. For example, setting it to '20S' will let the adapter keep requesting the connection for up to 20 seconds.
--|link:https://docs.oracle.com/javase/8/docs/api/java/time/Duration.html[Duration]
  link:#duration-note-anchor[icon:question-circle[], title=More information about the Duration format]
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.public-key]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.public-key[quarkus.oidc.""tenant"".public-key]`

[.description]
--
Public key for the local JWT token verification. OIDC server connection will not be created when this property is set.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.client-id]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.client-id[quarkus.oidc.""tenant"".client-id]`

[.description]
--
The client-id of the application. Each application has a client-id that is used to identify the application
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.roles.role-claim-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.roles.role-claim-path[quarkus.oidc.""tenant"".roles.role-claim-path]`

[.description]
--
Path to the claim containing an array of groups. It starts from the top level JWT JSON object and can contain multiple segments where each segment represents a JSON object name only, example: ""realm/groups"". Use double quotes with the namespace qualified claim names. This property can be used if a token has no 'groups' claim but has the groups set in a different claim.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.roles.role-claim-separator]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.roles.role-claim-separator[quarkus.oidc.""tenant"".roles.role-claim-separator]`

[.description]
--
Separator for splitting a string which may contain multiple group values. It will only be used if the ""role-claim-path"" property points to a custom claim whose value is a string. A single space will be used by default because the standard 'scope' claim may contain a space separated sequence.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.roles.source]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.roles.source[quarkus.oidc.""tenant"".roles.source]`

[.description]
--
Source of the principal roles.
--|`idtoken`, `accesstoken`, `userinfo` 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.issuer]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.issuer[quarkus.oidc.""tenant"".token.issuer]`

[.description]
--
Expected issuer 'iss' claim value.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.audience]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.audience[quarkus.oidc.""tenant"".token.audience]`

[.description]
--
Expected audience 'aud' claim value which may be a string or an array of strings.
--|list of string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.token-type]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.token-type[quarkus.oidc.""tenant"".token.token-type]`

[.description]
--
Expected token type
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.lifespan-grace]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.lifespan-grace[quarkus.oidc.""tenant"".token.lifespan-grace]`

[.description]
--
Life span grace period in seconds. When checking token expiry, current time is allowed to be later than token expiration time by at most the configured number of seconds. When checking token issuance, current time is allowed to be sooner than token issue time by at most the configured number of seconds.
--|int 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.principal-claim]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.principal-claim[quarkus.oidc.""tenant"".token.principal-claim]`

[.description]
--
Name of the claim which contains a principal name. By default, the 'upn', 'preferred_username' and `sub` claims are checked.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.refresh-expired]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.refresh-expired[quarkus.oidc.""tenant"".token.refresh-expired]`

[.description]
--
Refresh expired ID tokens. If this property is enabled then a refresh token request will be performed if the ID token has expired and, if successful, the local session will be updated with the new set of tokens. Otherwise, the local session will be invalidated and the user redirected to the OpenID Provider to re-authenticate. In this case the user may not be challenged again if the OIDC provider session is still active. For this option be effective the `authentication.session-age-extension` property should also be set to a non-zero value since the refresh token is currently kept in the user session. This option is valid only when the application is of type `ApplicationType++#++WEB_APP`++}++.
--|boolean 
|`false`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.auto-refresh-interval]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.auto-refresh-interval[quarkus.oidc.""tenant"".token.auto-refresh-interval]`

[.description]
--
Token auto-refresh interval in seconds during the user re-authentication. If this option is set then the valid ID token will be refreshed if it will expire in less than a number of minutes set by this option. The user will still be authenticated if the ID token can no longer be refreshed but is still valid. This option will be ignored if the 'refresh-expired' property is not enabled.
--|link:https://docs.oracle.com/javase/8/docs/api/java/time/Duration.html[Duration]
  link:#duration-note-anchor[icon:question-circle[], title=More information about the Duration format]
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.forced-jwk-refresh-interval]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.token.forced-jwk-refresh-interval[quarkus.oidc.""tenant"".token.forced-jwk-refresh-interval]`

[.description]
--
Forced JWK set refresh interval in minutes.
--|link:https://docs.oracle.com/javase/8/docs/api/java/time/Duration.html[Duration]
  link:#duration-note-anchor[icon:question-circle[], title=More information about the Duration format]
|`10M`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.credentials.secret]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.credentials.secret[quarkus.oidc.""tenant"".credentials.secret]`

[.description]
--
Client secret which is used for a 'client_secret_basic' authentication method. Note that a 'client-secret.value' can be used instead but both properties are mutually exclusive.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.credentials.client-secret.value]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.credentials.client-secret.value[quarkus.oidc.""tenant"".credentials.client-secret.value]`

[.description]
--
The client secret
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.credentials.client-secret.method]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.credentials.client-secret.method[quarkus.oidc.""tenant"".credentials.client-secret.method]`

[.description]
--
Authentication method.
--|`basic`, `post` 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.credentials.jwt.secret]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.credentials.jwt.secret[quarkus.oidc.""tenant"".credentials.jwt.secret]`

[.description]
--
client_secret_jwt: JWT which includes client id as one of its claims is signed by the client secret and is submitted as a 'client_assertion' form parameter, while 'client_assertion_type' parameter is set to ""urn:ietf:params:oauth:client-assertion-type:jwt-bearer"".
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.credentials.jwt.lifespan]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.credentials.jwt.lifespan[quarkus.oidc.""tenant"".credentials.jwt.lifespan]`

[.description]
--
JWT life-span in seconds. It will be added to the time it was issued at to calculate the expiration time.
--|int 
|`10`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.proxy.host]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.proxy.host[quarkus.oidc.""tenant"".proxy.host]`

[.description]
--
The host (name or IP address) of the Proxy.
 Note: If OIDC adapter needs to use a Proxy to talk with OIDC server (Provider), then at least the ""host"" config item must be configured to enable the usage of a Proxy.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.proxy.port]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.proxy.port[quarkus.oidc.""tenant"".proxy.port]`

[.description]
--
The port number of the Proxy. Default value is 80.
--|int 
|`80`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.proxy.username]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.proxy.username[quarkus.oidc.""tenant"".proxy.username]`

[.description]
--
The username, if Proxy needs authentication.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.proxy.password]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.proxy.password[quarkus.oidc.""tenant"".proxy.password]`

[.description]
--
The password, if Proxy needs authentication.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.redirect-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.redirect-path[quarkus.oidc.""tenant"".authentication.redirect-path]`

[.description]
--
Relative path for calculating a ""redirect_uri"" query parameter. It has to start from a forward slash and will be appended to the request URI's host and port. For example, if the current request URI is 'https://localhost:8080/service' then a 'redirect_uri' parameter will be set to 'https://localhost:8080/' if this property is set to '/' and be the same as the request URI if this property has not been configured. Note the original request URI will be restored after the user has authenticated.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.restore-path-after-redirect]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.restore-path-after-redirect[quarkus.oidc.""tenant"".authentication.restore-path-after-redirect]`

[.description]
--
If this property is set to 'true' then the original request URI which was used before the authentication will be restored after the user has been redirected back to the application.
--|boolean 
|`true`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.remove-redirect-parameters]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.remove-redirect-parameters[quarkus.oidc.""tenant"".authentication.remove-redirect-parameters]`

[.description]
--
Remove the query parameters such as 'code' and 'state' set by the OIDC server on the redirect URI after the user has authenticated by redirecting a user to the same URI but without the query parameters.
--|boolean 
|`true`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.verify-access-token]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.verify-access-token[quarkus.oidc.""tenant"".authentication.verify-access-token]`

[.description]
--
Both ID and access tokens are fetched from the OIDC provider as part of the authorization code flow. ID token is always verified on every user request as the primary token which is used to represent the principal and extract the roles. Access token is not verified by default since it is meant to be propagated to the downstream services. The verification of the access token should be enabled if it is injected as a JWT token. Access tokens obtained as part of the code flow will always be verified if `quarkus.oidc.roles.source` property is set to `accesstoken` which means the authorization decision will be based on the roles extracted from the access token. Bearer access tokens are always verified.
--|boolean 
|`false`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.force-redirect-https-scheme]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.force-redirect-https-scheme[quarkus.oidc.""tenant"".authentication.force-redirect-https-scheme]`

[.description]
--
Force 'https' as the 'redirect_uri' parameter scheme when running behind an SSL terminating reverse proxy. This property, if enabled, will also affect the logout `post_logout_redirect_uri` and the local redirect requests.
--|boolean 
|`false`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.scopes]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.scopes[quarkus.oidc.""tenant"".authentication.scopes]`

[.description]
--
List of scopes
--|list of string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.extra-params-extra-params]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.extra-params-extra-params[quarkus.oidc.""tenant"".authentication.extra-params]`

[.description]
--
Additional properties which will be added as the query parameters to the authentication redirect URI.
--|`Map<String,String>` 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.cookie-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.cookie-path[quarkus.oidc.""tenant"".authentication.cookie-path]`

[.description]
--
Cookie path parameter value which, if set, will be used for the session, state and post logout cookies. It may need to be set when the redirect path has a root different to that of the original request URL.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.cookie-domain]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.cookie-domain[quarkus.oidc.""tenant"".authentication.cookie-domain]`

[.description]
--
Cookie domain parameter value which, if set, will be used for the session, state and post logout cookies.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.user-info-required]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.user-info-required[quarkus.oidc.""tenant"".authentication.user-info-required]`

[.description]
--
If this property is set to 'true' then an OIDC UserInfo endpoint will be called
--|boolean 
|`false`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.session-age-extension]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.session-age-extension[quarkus.oidc.""tenant"".authentication.session-age-extension]`

[.description]
--
Session age extension in minutes. The user session age property is set to the value of the ID token life-span by default and the user will be redirected to the OIDC provider to re-authenticate once the session has expired. If this property is set to a non-zero value then the expired ID token can be refreshed before the session has expired. This property will be ignored if the `token.refresh-expired` property has not been enabled.
--|link:https://docs.oracle.com/javase/8/docs/api/java/time/Duration.html[Duration]
  link:#duration-note-anchor[icon:question-circle[], title=More information about the Duration format]
|`5M`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.xhr-auto-redirect]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.authentication.xhr-auto-redirect[quarkus.oidc.""tenant"".authentication.xhr-auto-redirect]`

[.description]
--
If this property is set to 'true' then a normal 302 redirect response will be returned if the request was initiated via XMLHttpRequest and the current user needs to be (re)authenticated which may not be desirable for Single Page Applications since XMLHttpRequest automatically following the redirect may not work given that OIDC authorization endpoints typically do not support CORS. If this property is set to `false` then a status code of '499' will be returned to allow the client to handle the redirect manually
--|boolean 
|`true`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.tls.verification]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.tls.verification[quarkus.oidc.""tenant"".tls.verification]`

[.description]
--
Certificate validation and hostname verification, which can be one of the following values from enum `Verification`. Default is required.
--|`required`, `none` 
|`required`


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.logout.path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.logout.path[quarkus.oidc.""tenant"".logout.path]`

[.description]
--
The relative path of the logout endpoint at the application. If provided, the application is able to initiate the logout through this endpoint in conformance with the OpenID Connect RP-Initiated Logout specification.
--|string 
|


a| [[quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.logout.post-logout-path]]`link:#quarkus-oidc-oidc-config_quarkus.oidc.-tenant-.logout.post-logout-path[quarkus.oidc.""tenant"".logout.post-logout-path]`

[.description]
--
Relative path of the application endpoint where the user should be redirected to after logging out from the OpenID Connect Provider. This endpoint URI must be properly registered at the OpenID Connect Provider as a valid redirect URI.
--|string 
|

|===
ifndef::no-duration-note[]
[NOTE]
[[duration-note-anchor]]
.About the Duration format
====
The format for durations uses the standard `java.time.Duration` format.
You can learn more about it in the link:https://docs.oracle.com/javase/8/docs/api/java/time/Duration.html#parse-java.lang.CharSequence-[Duration#parse() javadoc].

You can also provide duration values starting with a number.
In this case, if the value consists only of a number, the converter treats the value as seconds.
Otherwise, `PT` is implicitly prepended to the value to obtain a standard `java.time.Duration` format.
====
endif::no-duration-note[]
",12367,True,3799.4508652479053,median
"[[release-notes-7.3.2]]
== {es} version 7.3.2

Also see <<breaking-changes-7.3,Breaking changes in 7.3>>.

[[bug-7.3.2]]
[discrete]
=== Bug fixes

Data Frame::
* Fix off-by-one error in checkpoint operations_behind {es-pull}46235[#46235]

Distributed::
* Update translog checkpoint after marking operations as persisted {es-pull}45634[#45634] (issue: {es-issue}29161[#29161])

Engine::
* Handle delete document level failures {es-pull}46100[#46100] (issue: {es-issue}46083[#46083])
* Handle no-op document level failures {es-pull}46083[#46083]

Infra/Scripting::
* Fix bugs in Painless SCatch node {es-pull}45880[#45880]

Machine learning::
* Throw an error when a datafeed needs {ccs} but it is not enabled for the node {es-pull}46044[#46044]

SQL::
* SQL: Fix issue with IIF function when condition folds {es-pull}46290[#46290] (issue: {es-issue}46268[#46268])
* SQL: Fix issue with DataType for CASE with NULL {es-pull}46173[#46173] (issue: {es-issue}46032[#46032])

Search::
* Multi-get requests should wait for search active {es-pull}46283[#46283] (issue: {es-issue}27500[#27500])
* Ensure top docs optimization is fully disabled for queries with unbounded max scores. {es-pull}46105[#46105] (issue: {es-issue}45933[#45933])


[[release-notes-7.3.1]]
== {es} version 7.3.1

Also see <<breaking-changes-7.3,Breaking changes in 7.3>>.

[[enhancement-7.3.1]]
[discrete]
=== Enhancements

CCR::
* Include leases in error message when operations are no longer available {es-pull}45681[#45681]

Infra/Core::
* Add OCI annotations and adjust existing annotations {es-pull}45167[#45167] (issues: {es-issue}45162[#45162], {es-issue}45166[#45166])

Infra/Settings::
* Normalize environment paths {es-pull}45179[#45179] (issue: {es-issue}45176[#45176])

Machine Learning::
* Outlier detection should only fetch docs that have the analyzed fields {es-pull}44944[#44944]

SQL::
* Remove deprecated use of ""interval"" from date_histogram usage {es-pull}45501[#45501] (issue: {es-issue}43922[#43922])


[[bug-7.3.1]]
[discrete]
=== Bug fixes

Aggregations::
* Fix early termination of aggregators that run with breadth-first mode {es-pull}44963[#44963] (issue: {es-issue}44909[#44909])

Analysis::
* Enable reloading of synonym_graph filters {es-pull}45135[#45135] (issue: {es-issue}45127[#45127])

Authentication::
* Do not use scroll when finding duplicate API key {es-pull}45026[#45026]
* Fix broken short-circuit in getUnlicensedRealms {es-pull}44399[#44399]

CCR::
* Clean up ShardFollowTasks for deleted indices {es-pull}44702[#44702] (issue: {es-issue}34404[#34404])

CRUD::
* Allow _update on write alias {es-pull}45318[#45318] (issue: {es-issue}31520[#31520])

Data Frame::
* Fix starting a batch {dataframe-transform} after stopping at runtime
{es-pull}45340[#45340] (issues: {es-issue}44219[#44219], {es-issue}45339[#45339])
* Fix null aggregation handling in indexer {es-pull}45061[#45061] (issue: {es-issue}44906[#44906])

Distributed::
* Ensure AsyncTask#isScheduled remains false after close {es-pull}45687[#45687] (issue: {es-issue}45576[#45576])
* Fix clock used in update requests {es-pull}45262[#45262] (issue: {es-issue}45254[#45254])
* Restore DefaultShardOperationFailedException's reason during deserialization {es-pull}45203[#45203]

Features/Watcher::
* Fix watcher HttpClient URL creation {es-pull}45207[#45207] (issue: {es-issue}44970[#44970])

Infra/Packaging::
* Use bundled JDK in Sys V init {es-pull}45593[#45593] (issue: {es-issue}45542[#45542])

Infra/Settings::
* Fix a bug with elasticsearch.common.settings.Settings.processSetting {es-pull}44047[#44047] (issue: {es-issue}43791[#43791])

MULTIPLE AREA LABELS::
* Fix a bug where mappings are dropped from rollover requests. {es-pull}45411[#45411] (issue: {es-issue}45399[#45399])
* Sparse role queries can throw an NPE {es-pull}45053[#45053]

Machine Learning::
* Check dest index is empty when starting {dfanalytics} {es-pull}45094[#45094]
* Catch any error thrown while closing {dfanalytics} process {es-pull}44958[#44958]
* Only trap the case where more rows are supplied to outlier detection than
expected. Previously, if rows were excluded from the {dataframe-transform} after supplying the row count in the configuration, we detected the inconsistency and
failed outlier detection. However, this situation legitimately happens in cases
where the field values are non-numeric or array valued. {ml-pull}569[#569]

Mapping::
* Make sure to validate the type before attempting to merge a new mapping. {es-pull}45157[#45157] (issues: {es-issue}29316[#29316], {es-issue}43012[#43012])

SQL::
* Adds format parameter to range queries for constant date comparisons {es-pull}45326[#45326] (issue: {es-issue}45139[#45139])
* Uniquely named inner_hits sections for each nested field condition {es-pull}45039[#45039] (issues: {es-issue}33080[#33080], {es-issue}44544[#44544])
* Fix URI path being lost in case of hosted ES scenario {es-pull}44776[#44776] (issue: {es-issue}44721[#44721])

Search::
* Prevent Leaking Search Tasks on Exceptions in FetchSearchPhase and DfsQueryPhase {es-pull}45500[#45500]
* Fix an NPE when requesting inner hits and _source is disabled. {es-pull}44836[#44836] (issue: {es-issue}43517[#43517])

Security::
* Fix .security-* indices auto-create {es-pull}44918[#44918]
* Use system context for looking up connected nodes {es-pull}43991[#43991] (issue: {es-issue}43974[#43974])



[[upgrade-7.3.1]]
[discrete]
=== Upgrades

Infra/Packaging::
* Upgrade to JDK 12.0.2 {es-pull}45172[#45172]


[[release-notes-7.3.0]]
== {es} version 7.3.0

Also see <<breaking-changes-7.3,Breaking changes in 7.3>>.


[discrete]
=== Known issues

* Applying deletes or updates on an index after it has been shrunk may corrupt
the index. In order to prevent this issue, it is recommended to stop shrinking
read-write indices. For read-only indices, it is recommended to force-merge
indices after shrinking, which significantly reduces the likeliness of this
corruption in the case that deletes/updates would be applied by mistake. This
bug is fixed in {es} 7.7 and later versions. More details can be found on the
https://issues.apache.org/jira/browse/LUCENE-9300[corresponding issue].

* Indices created in 6.x with <<date,`date`>> and <<date_nanos,`date_nanos`>> fields using formats
that are incompatible with java.time patterns will cause parsing errors, incorrect date calculations or wrong search results.
https://github.com/elastic/elasticsearch/pull/52555
This is fixed in {es} 7.7 and later versions.


[[breaking-7.3.0]]
[discrete]
=== Breaking changes

CCR::
* Do not allow modify aliases on followers {es-pull}43017[#43017] (issue: {es-issue}41396[#41396])

Data Frame::
* Removing format support in date_histogram group_by {es-pull}43659[#43659]

[[breaking-java-7.3.0]]
[discrete]
=== Breaking Java changes

Mapping::
* Refactor put mapping request validation for reuse {es-pull}43005[#43005] (issues: {es-issue}37675[#37675], {es-issue}41396[#41396])

Search::
* Refactor IndexSearcherWrapper to disallow the wrapping of IndexSearcher {es-pull}43645[#43645]



[[deprecation-7.3.0]]
[discrete]
=== Deprecations

Features/Java High Level REST Client::
* Deprecate native code info in xpack info api {es-pull}43297[#43297]

Mapping::
* Deprecate support for chained multi-fields. {es-pull}41926[#41926] (issue: {es-issue}41267[#41267])

Network::
* Deprecate transport profile security type setting {es-pull}43237[#43237]

Search::
* Deprecate CommonTermsQuery and cutoff_frequency {es-pull}42619[#42619] (issue: {es-issue}37096[#37096])



[[feature-7.3.0]]
[discrete]
=== New features

Aggregations::
* Adds a minimum interval to `auto_date_histogram`. {es-pull}42814[#42814] (issue: {es-issue}41757[#41757])
* Add RareTerms aggregation {es-pull}35718[#35718] (issue: {es-issue}20586[#20586])

Audit::
* Enable console audit logs for docker {es-pull}42671[#42671] (issue: {es-issue}42666[#42666])

Data Frame::
* Add sync api {es-pull}41800[#41800]

Infra/Settings::
* Consistent Secure Settings {es-pull}40416[#40416]

Machine Learning::
* Machine learning data frame analytics {es-pull}43544[#43544]

Mapping::
* Add support for 'flattened object' fields. {es-pull}42541[#42541] (issues: {es-issue}25312[#25312], {es-issue}33003[#33003])

Ranking::
* Move dense_vector and sparse_vector to module {es-pull}43280[#43280]

SQL::
* SQL: Add support for FROZEN indices {es-pull}41558[#41558] (issues: {es-issue}39377[#39377], {es-issue}39390[#39390])

Search::
* Wildcard intervals {es-pull}43691[#43691] (issue: {es-issue}43198[#43198])
* Add prefix intervals source {es-pull}43635[#43635] (issue: {es-issue}43198[#43198])



[[enhancement-7.3.0]]
[discrete]
=== Enhancements

Aggregations::
* Allocate memory lazily in BestBucketsDeferringCollector {es-pull}43339[#43339] (issue: {es-issue}43091[#43091])
* Reduce the number of docvalues iterator created in the global ordinals fielddata {es-pull}43091[#43091]

Analysis::
* Return reloaded analyzers in _reload_search_ananlyzer response {es-pull}43813[#43813] (issue: {es-issue}43804[#43804])
* Allow reloading of search time analyzers {es-pull}43313[#43313] (issue: {es-issue}29051[#29051])
* Allow reloading of search time analyzers {es-pull}42888[#42888] (issue: {es-issue}29051[#29051])
* Allow reloading of search time analyzers {es-pull}42669[#42669] (issue: {es-issue}29051[#29051])

Authentication::
* Always attach system user to internal actions {es-pull}43468[#43468] (issue: {es-issue}42215[#42215])
* Add kerberos grant_type to get token in exchange for Kerberos ticket {es-pull}42847[#42847] (issue: {es-issue}41943[#41943])
* Permit API Keys on Basic License {es-pull}42787[#42787]

Authorization::
* Add ""manage_api_key"" cluster privilege {es-pull}43728[#43728] (issue: {es-issue}42020[#42020])
* Use separate BitSet cache in Doc Level Security {es-pull}43669[#43669] (issue: {es-issue}30974[#30974])
* Support builtin privileges in get privileges API {es-pull}42134[#42134] (issue: {es-issue}29771[#29771])

CCR::
* Replicate aliases in cross-cluster replication {es-pull}41815[#41815] (issue: {es-issue}41396[#41396])

Cluster Coordination::
* Ignore unknown fields if overriding node metadata {es-pull}44689[#44689]
* Add voting-only master node {es-pull}43410[#43410] (issue: {es-issue}14340[#14340])
* Defer reroute when nodes join {es-pull}42855[#42855]
* Stop SeedHostsResolver on shutdown {es-pull}42844[#42844]
* Log leader and handshake failures by default {es-pull}42342[#42342] (issue: {es-issue}42153[#42153])

Data Frame::
* Add a frequency option to transform config, default 1m {es-pull}44120[#44120]
* Add node attr to GET _stats {es-pull}43842[#43842] (issue: {es-issue}43743[#43743])
* Add deduced mappings to _preview response payload {es-pull}43742[#43742] (issue: {es-issue}39250[#39250])
* Add support for allow_no_match for endpoints {es-pull}43490[#43490] (issue: {es-issue}42766[#42766])
* Add version and create_time to transform config {es-pull}43384[#43384] (issue: {es-issue}43037[#43037])
* Have sum map to a double to prevent overflows {es-pull}43213[#43213]
* Add new pipeline field to dest config {es-pull}43124[#43124] (issue: {es-issue}43061[#43061])
* Write a warning audit on bulk index failures {es-pull}43106[#43106]
* Add support for weighted_avg agg {es-pull}42646[#42646]

Distributed::
* Improve Close Index Response {es-pull}39687[#39687] (issue: {es-issue}33888[#33888])

Engine::
* Use reader attributes to control term dict memory useage {es-pull}42838[#42838] (issue: {es-issue}38390[#38390])
* Remove sort by primary term when reading soft-deletes {es-pull}43845[#43845]
* Refresh translog stats after translog trimming in NoOpEngine {es-pull}43825[#43825] (issue: {es-issue}43156[#43156])
* Expose translog stats in ReadOnlyEngine {es-pull}43752[#43752]
* Do not use soft-deletes to resolve indexing strategy {es-pull}43336[#43336] (issues: {es-issue}35230[#35230], {es-issue}42979[#42979], {es-issue}43202[#43202])
* Rebuild version map when opening internal engine {es-pull}43202[#43202] (issues: {es-issue}40741[#40741], {es-issue}42979[#42979])
* Only load FST off heap if we are actually using mmaps for the term dictionary {es-pull}43158[#43158] (issue: {es-issue}43150[#43150])
* Trim translog for closed indices {es-pull}43156[#43156] (issue: {es-issue}42445[#42445])
* Also mmap terms index (`.tip`) files for hybridfs {es-pull}43150[#43150] (issue: {es-issue}42838[#42838])
* Add a merge policy that prunes ID postings for soft-deleted but retained documents {es-pull}40741[#40741]

Features/Indices APIs::
* Remove ""template"" field in IndexTemplateMetadata {es-pull}42099[#42099] (issue: {es-issue}38502[#38502])

Features/Ingest::
* Avoid HashMap construction on Grok non-match {es-pull}42444[#42444]
* Improve how internal representation of pipelines are updated {es-pull}42257[#42257]

Features/Java High Level REST Client::
* Add _reload_search_analyzers endpoint to HLRC {es-pull}43733[#43733] (issue: {es-issue}43313[#43313])
* Bulk processor concurrent requests {es-pull}41451[#41451]

Features/Java Low Level REST Client::
* Adapt low-level REST client to java 8 {es-pull}41537[#41537] (issue: {es-issue}38540[#38540])

Features/Monitoring::
* Expand beats_system role privileges {es-pull}40876[#40876]

Features/Watcher::
* Improve CryptoService error message on missing secure file {es-pull}43623[#43623] (issue: {es-issue}43619[#43619])
* Watcher: Allow to execute actions for each element in array {es-pull}41997[#41997] (issue: {es-issue}34546[#34546])

Infra/Core::
* Shortcut simple patterns ending in `*` {es-pull}43904[#43904]
* Prevent merging nodes' data paths {es-pull}42665[#42665] (issue: {es-issue}42489[#42489])
* Deprecation info for joda-java migration on 7.x {es-pull}42659[#42659] (issue: {es-issue}42010[#42010])
* Implement XContentParser.genericMap and XContentParser.genericMapOrdered methods {es-pull}42059[#42059]

Infra/Packaging::
* Omit JDK sources archive from bundled JDK {es-pull}42821[#42821]

Infra/Plugins::
* Enable node roles to be pluggable {es-pull}43175[#43175]

Infra/Scripting::
* Add annotations to Painless whitelist {es-pull}43239[#43239]
* Add painless method getByPath, get value from nested collections with dotted path {es-pull}43170[#43170] (issue: {es-issue}42769[#42769])
* Add painless method getByPath, get value from nested collections with dotted path {es-pull}43129[#43129] (issue: {es-issue}42769[#42769])

Machine Learning::
* Add version and create_time to data frame analytics config {es-pull}43683[#43683]
* Improve message when native controller cannot connect {es-pull}43565[#43565] (issue: {es-issue}42341[#42341])
* Report exponential_avg_bucket_processing_time which gives more weight to recent buckets {es-pull}43189[#43189] (issue: {es-issue}29857[#29857])
* Adding support for geo_shape, geo_centroid, geo_point in datafeeds {es-pull}42969[#42969] (issue: {es-issue}42820[#42820])
* Report timing stats as part of the Job stats response {es-pull}42709[#42709] (issue: {es-issue}29857[#29857])
* Increase maximum forecast interval to 10 years. {es-pull}41082[#41082] (issue: {es-issue}41103[#41103])
* Upgrade to a newer version of the Apache Portable Runtime library. {ml-pull}495[#495]
* Improve stability of modelling around change points. {ml-pull}496[#496]
* Restrict detection of epoch timestamps in find_file_structure {es-pull}43188[#43188]
* Better detection of binary input in find_file_structure {es-pull}42707[#42707]
* Add a limit on line merging in find_file_structure {es-pull}42501[#42501] (issue: {es-issue}38086[#38086])
* Improve file structure finder timestamp format determination {es-pull}41948[#41948] (issues: {es-issue}35132[#35132], {es-issue}35137[#35137], {es-issue}38086[#38086])
* Add earliest and latest timestamps to field stats in find_file_structure response {es-pull}42890[#42890]
* Change dots in CSV column names to underscores in find_file_structure response {es-pull}42839[#42839] (issue: {es-issue}26800[#26800])

Mapping::
* Add dims parameter to dense_vector mapping {es-pull}43444[#43444]
* Added parsing of erroneous field value {es-pull}42321[#42321] (issue: {es-issue}41372[#41372])

Network::
* Do not hang on unsupported HTTP methods {es-pull}43362[#43362]

Ranking::
* Fix parameter value for calling data.advanceExact {es-pull}44205[#44205]
* Distance measures for dense and sparse vectors {es-pull}37947[#37947] (issue: {es-issue}31615[#31615])

Recovery::
* Make peer recovery send file info step async {es-pull}43792[#43792] (issue: {es-issue}36195[#36195])
* Make peer recovery clean files step async {es-pull}43787[#43787] (issue: {es-issue}36195[#36195])

Reindex::
* Reindex max_docs parameter name {es-pull}41894[#41894] (issue: {es-issue}24344[#24344])

Search::
* Split search in two when made against read-only and write indices {es-pull}42510[#42510] (issue: {es-issue}40900[#40900])
* Rename SearchRequest#crossClusterSearch {es-pull}42363[#42363]
* Allow `fields` to be set to `*` {es-pull}42301[#42301] (issue: {es-issue}39577[#39577])
* Search - enable low_level_cancellation by default. {es-pull}42291[#42291] (issue: {es-issue}26258[#26258])
* Cut over ClusterSearchShardsGroup to Writeable {es-pull}41788[#41788]
* Disable max score optimization for queries with unbounded max scores {es-pull}41361[#41361]

Snapshot/Restore::
* Recursive Delete on BlobContainer {es-pull}43281[#43281] (issue: {es-issue}42189[#42189])
* Add SAS Token Authentication Support to Azure Repo Plugin {es-pull}42982[#42982] (issue: {es-issue}42117[#42117])
* Enable Parallel Deletes in Azure Repository {es-pull}42783[#42783]
* Add Ability to List Child Containers to BlobContainer {es-pull}42653[#42653] (issue: {es-issue}42189[#42189])
* Add custom metadata to snapshots {es-pull}41281[#41281] (issue: {es-issue}40638[#40638])

Store::
* Shard CLI tool always check shards {es-pull}41480[#41480] (issue: {es-issue}41298[#41298])



[[bug-7.3.0]]
[discrete]
=== Bug fixes

Aggregations::
* Fix incorrect calculation of how many buckets will result from a merge {es-pull}44461[#44461] (issue: {es-issue}43577[#43577])
* Set document on script when using Bytes.WithScript {es-pull}43390[#43390]
* Bug fix to allow access to top level params in reduce script {es-pull}42096[#42096] (issue: {es-issue}42046[#42046])

Allocation::
* Do not copy initial recovery filter during split {es-pull}44053[#44053] (issue: {es-issue}43955[#43955])
* Avoid parallel reroutes in DiskThresholdMonitor {es-pull}43381[#43381] (issue: {es-issue}40174[#40174])
* Reset failed allocation counter before executing routing commands {es-pull}42658[#42658] (issue: {es-issue}39546[#39546])
* Validate routing commands using updated routing state {es-pull}42066[#42066] (issue: {es-issue}41050[#41050])

Analysis::
* Fix AnalyzeAction response serialization {es-pull}44284[#44284] (issue: {es-issue}44078[#44078])
* Actually close IndexAnalyzers contents {es-pull}43914[#43914]
* Issue deprecation warnings for preconfigured delimited_payload_filter {es-pull}43684[#43684] (issues: {es-issue}26625[#26625], {es-issue}43568[#43568])
* Use preconfigured filters correctly in Analyze API {es-pull}43568[#43568] (issue: {es-issue}43002[#43002])
* Require [articles] setting in elision filter {es-pull}43083[#43083] (issue: {es-issue}43002[#43002])

Authentication::
* Fix broken short-circuit in getUnlicensedRealms {es-pull}44399[#44399]
* Fix Token Service retry mechanism {es-pull}39639[#39639]

CCR::
* Skip update if leader and follower settings identical {es-pull}44535[#44535] (issue: {es-issue}44521[#44521])
* Avoid stack overflow in auto-follow coordinator {es-pull}44421[#44421] (issue: {es-issue}43251[#43251])
* Avoid NPE when checking for CCR index privileges {es-pull}44397[#44397] (issue: {es-issue}44172[#44172])
* CCR should not replicate private/internal settings {es-pull}43067[#43067] (issue: {es-issue}41268[#41268])

CRUD::
* Fix NPE when rejecting bulk updates {es-pull}42923[#42923]
* Fix ""size"" field in the body of AbstractBulkByScrollRequest {es-pull}35742[#35742] (issue: {es-issue}35636[#35636])

Cluster Coordination::
* Local node is discovered when cluster fails {es-pull}43316[#43316]
* Reset state recovery after successful recovery {es-pull}42576[#42576] (issue: {es-issue}39172[#39172])
* Cluster state from API should always have a master {es-pull}42454[#42454] (issues: {es-issue}38331[#38331], {es-issue}38432[#38432])
* Omit non-masters in ClusterFormationFailureHelper {es-pull}41344[#41344]

Data Frame::
* Treat bulk index failures as an indexing failure {es-pull}44351[#44351] (issue: {es-issue}44101[#44101])
* Responding with 409 status code when failing _stop {es-pull}44231[#44231] (issue: {es-issue}44103[#44103])
* Adds index validations to _start data frame transform {es-pull}44191[#44191] (issue: {es-issue}44104[#44104])
* Data frame task failure do not make a 500 response {es-pull}44058[#44058] (issue: {es-issue}44011[#44011])
* Audit message missing for autostop {es-pull}43984[#43984] (issue: {es-issue}43977[#43977])
* Add data frame transform cluster privileges to HLRC {es-pull}43879[#43879]
* Improve pivot nested field validations {es-pull}43548[#43548]
* Adjusting error message {es-pull}43455[#43455]
* Size the GET stats search by number of Ids requested {es-pull}43206[#43206] (issue: {es-issue}43203[#43203])
* Rewrite start and stop to answer with acknowledged {es-pull}42589[#42589] (issue: {es-issue}42450[#42450])
* Set data frame transform task state to stopped when stopping   {es-pull}42516[#42516] (issue: {es-issue}42441[#42441])

Distributed::
* Fix DefaultShardOperationFailedException subclass xcontent serialization {es-pull}43435[#43435] (issue: {es-issue}43423[#43423])
* Advance checkpoints only after persisting ops {es-pull}43205[#43205]
* Avoid loading retention leases while writing them {es-pull}42620[#42620] (issue: {es-issue}41430[#41430])
* Do not use ifSeqNo for update requests on mixed cluster {es-pull}42596[#42596] (issue: {es-issue}42561[#42561])
* Ensure relocation target still tracked when start handoff {es-pull}42201[#42201]

Engine::
* AsyncIOProcessor preserve thread context {es-pull}43729[#43729]
* Account soft deletes for committed segments {es-pull}43126[#43126] (issue: {es-issue}43103[#43103])
* Prune _id of only docs below local checkpoint of safe commit {es-pull}43051[#43051] (issues: {es-issue}40741[#40741], {es-issue}42979[#42979])
* Improve translog corruption detection {es-pull}42744[#42744] (issue: {es-issue}42661[#42661])

Features/CAT APIs::
* Fix indices shown in _cat/indices {es-pull}43286[#43286] (issues: {es-issue}33888[#33888], {es-issue}38824[#38824], {es-issue}39933[#39933])

Features/ILM::
* Fix swapped variables in error message {es-pull}44300[#44300]
* Account for node versions during allocation in ILM Shrink {es-pull}43300[#43300] (issue: {es-issue}41879[#41879])
* Narrow period of Shrink action in which ILM prevents stopping {es-pull}43254[#43254] (issue: {es-issue}43253[#43253])
* Make ILM force merging best effort {es-pull}43246[#43246] (issues: {es-issue}42824[#42824], {es-issue}43245[#43245])

Features/Indices APIs::
* Check shard limit after applying index templates {es-pull}44619[#44619] (issues: {es-issue}34021[#34021], {es-issue}44567[#44567], {es-issue}44619[#44619])
* Validate index settings after applying templates {es-pull}44612[#44612] (issues: {es-issue}34021[#34021], {es-issue}44567[#44567])
* Prevent NullPointerException in TransportRolloverAction {es-pull}43353[#43353] (issue: {es-issue}43296[#43296])

Features/Ingest::
* Read the default pipeline for bulk upsert through an alias {es-pull}41963[#41963]

Features/Java High Level REST Client::
* Fix CreateRepository Requeset in HLRC {es-pull}43522[#43522] (issue: {es-issue}43521[#43521])

Features/Stats::
* Return 0 for negative ""free"" and ""total"" memory reported by the OS {es-pull}42725[#42725] (issue: {es-issue}42157[#42157])

Features/Watcher::
* NullPointerException when creating a watch with Jira action (#41922) {es-pull}42081[#42081]
* fix unlikely bug that can prevent Watcher from restarting {es-pull}42030[#42030]

Infra/Core::
* Add default CLI JVM options {es-pull}44545[#44545] (issues: {es-issue}219[#219], {es-issue}42021[#42021])
* scheduleAtFixedRate would hang {es-pull}42993[#42993] (issue: {es-issue}38441[#38441])
* Only ignore IOException when fsyncing on dirs {es-pull}42972[#42972] (issue: {es-issue}42950[#42950])
* Fix alpha build error message when generate version object from version string {es-pull}40406[#40406]
* Bat scripts to work with JAVA_HOME with parantheses {es-pull}39712[#39712] (issues: {es-issue}30606[#30606], {es-issue}33405[#33405], {es-issue}38578[#38578], {es-issue}38624[#38624])
* Change licence expiration date pattern {es-pull}39681[#39681] (issue: {es-issue}39136[#39136])

Infra/Packaging::
* Restore setting up temp dir for windows service {es-pull}44541[#44541]
* Fix the bundled jdk flag to be passed through windows startup {es-pull}43502[#43502]

Infra/Plugins::
* Do not checksum all bytes at once in plugin install {es-pull}44649[#44649] (issue: {es-issue}44545[#44545])

Infra/REST API::
* Remove deprecated _source_exclude and _source_include from get API spec {es-pull}42188[#42188]

Infra/Scripting::
* Allow aggregations using expressions to use _score {es-pull}42652[#42652]

Machine Learning::
* Update .ml-config mappings before indexing job, datafeed or df analytics config {es-pull}44216[#44216] (issue: {es-issue}44263[#44263])
* Wait for .ml-config primary before assigning persistent tasks {es-pull}44170[#44170] (issue: {es-issue}44156[#44156])
* Fix ML memory tracker lockup when inner step fails {es-pull}44158[#44158] (issue: {es-issue}44156[#44156])
* Reduce false positives associated with the multi-bucket feature. {ml-pull}491[#491]
* Reduce false positives for sum and count functions on sparse data. {ml-pull}492[#492]
* Fix an edge case causing spurious anomalies (false positives) if the variance
in the count of events changed significantly throughout the period of a seasonal
quantity. (See {ml-pull}489[#489].)

Mapping::
* Ensure field caps doesn't error on rank feature fields. {es-pull}44370[#44370] (issue: {es-issue}44330[#44330])
* Prevent types deprecation warning for indices.exists requests {es-pull}43963[#43963] (issue: {es-issue}43905[#43905])
* Fix index_prefix sub field name on nested text fields {es-pull}43862[#43862] (issue: {es-issue}43741[#43741])
* Fix possible NPE in put mapping validators {es-pull}43000[#43000] (issue: {es-issue}37675[#37675])
* Allow big integers and decimals to be mapped dynamically. {es-pull}42827[#42827] (issue: {es-issue}37846[#37846])

Network::
* Reconnect remote cluster when seeds are changed {es-pull}43379[#43379] (issue: {es-issue}37799[#37799])
* Don't require TLS for single node clusters {es-pull}42826[#42826]
* Fix Class Load Order in Netty4Plugin {es-pull}42591[#42591] (issue: {es-issue}42532[#42532])

Recovery::
* Ensure to access RecoveryState#fileDetails under lock {es-pull}43839[#43839]
* Make Recovery API support `detailed` params {es-pull}29076[#29076] (issue: {es-issue}28910[#28910])

Reindex::
* Properly serialize remote query in ReindexRequest {es-pull}43457[#43457] (issues: {es-issue}43406[#43406], {es-issue}43456[#43456])
* Fixing handling of auto slices in bulk scroll requests {es-pull}43050[#43050]
* Remote reindex failure parse fix {es-pull}42928[#42928]
* Fix concurrent search and index delete {es-pull}42621[#42621] (issue: {es-issue}28053[#28053])
* Propogate version in reindex from remote search {es-pull}42412[#42412] (issue: {es-issue}31908[#31908])

SQL::
* SQL: change the size of the list of concrete indices when resolving multiple indices {es-pull}43878[#43878] (issue: {es-issue}43876[#43876])
* SQL: handle double quotes escaping {es-pull}43829[#43829] (issue: {es-issue}43810[#43810])
* SQL: add pretty printing to JSON format {es-pull}43756[#43756]
* SQL: handle SQL not being available in a more graceful way {es-pull}43665[#43665] (issue: {es-issue}41279[#41279])
* SQL: fix NPE in case of subsequent scrolled requests for a CSV/TSV formatted response {es-pull}43365[#43365] (issue: {es-issue}43327[#43327])
* Geo: Add coerce support to libs/geo WKT parser {es-pull}43273[#43273] (issue: {es-issue}43173[#43173])
* SQL: Increase hard limit for sorting on aggregates {es-pull}43220[#43220] (issue: {es-issue}43168[#43168])
* SQL: Fix wrong results when sorting on aggregate {es-pull}43154[#43154] (issue: {es-issue}42851[#42851])
* SQL: cover the Integer type when extracting values from _source {es-pull}42859[#42859] (issue: {es-issue}42858[#42858])

Search::
* Don't use index_phrases on graph queries {es-pull}44340[#44340] (issue: {es-issue}43976[#43976])
* Fix wrong logic in `match_phrase` query with multi-word synonyms {es-pull}43941[#43941] (issue: {es-issue}43308[#43308])
* Fix UOE on search requests that match a sparse role query {es-pull}43668[#43668] (issue: {es-issue}42857[#42857])
* Fix propagation of enablePositionIncrements in QueryStringQueryBuilder {es-pull}43578[#43578] (issue: {es-issue}43574[#43574])
* Fix score mode of the MinimumScoreCollector {es-pull}43527[#43527] (issue: {es-issue}43497[#43497])
* Fix round up of date range without rounding {es-pull}43303[#43303] (issue: {es-issue}43277[#43277])
* SearchRequest#allowPartialSearchResults does not handle successful retries {es-pull}43095[#43095] (issue: {es-issue}40743[#40743])
* Wire query cache into sorting nested-filter computation {es-pull}42906[#42906] (issue: {es-issue}42813[#42813])
* Fix auto fuzziness in query_string query {es-pull}42897[#42897]
* Fix IntervalBuilder#analyzeText to never return `null` {es-pull}42750[#42750] (issue: {es-issue}42587[#42587])
* Fix sorting on nested field with unmapped {es-pull}42451[#42451] (issue: {es-issue}33644[#33644])
* Deduplicate alias and concrete fields in query field expansion {es-pull}42328[#42328]

Security::
* Do not swallow I/O exception getting authentication {es-pull}44398[#44398] (issues: {es-issue}44172[#44172], {es-issue}44397[#44397])
* Use system context for looking up connected nodes {es-pull}43991[#43991] (issue: {es-issue}43974[#43974])
* SecurityIndexSearcherWrapper doesn't always carry over caches and similarity {es-pull}43436[#43436]
* Detect when security index is closed {es-pull}42191[#42191]

Snapshot/Restore::
* Check again on-going snapshots/restores of indices before closing {es-pull}43873[#43873]
* Fix Azure List by Prefix Bug {es-pull}42713[#42713]

Store::
* Remove usage of FileSwitchDirectory  {es-pull}42937[#42937] (issue: {es-issue}37111[#37111])
* Fix Infinite Loops in ExceptionsHelper#unwrap {es-pull}42716[#42716] (issue: {es-issue}42340[#42340])

Suggesters::
* Fix suggestions for empty indices {es-pull}42927[#42927] (issue: {es-issue}42473[#42473])
* Skip explain phase when only suggestions are requested {es-pull}41739[#41739] (issue: {es-issue}31260[#31260])



[[regression-7.3.0]]
[discrete]
=== Regressions

Infra/Core::
* Restore date aggregation performance in UTC case {es-pull}38221[#38221] (issue: {es-issue}37826[#37826])



[[upgrade-7.3.0]]
[discrete]
=== Upgrades

Discovery-Plugins::
* Upgrade AWS SDK to Latest Version {es-pull}42708[#42708]

Engine::
* Upgrade to Lucene 8.1.0 {es-pull}42214[#42214]

Infra/Core::
* Upgrade HPPC to version 0.8.1 {es-pull}43025[#43025]

Network::
* Upgrade to Netty 4.1.36 {es-pull}42543[#42543] (issue: {es-issue}42532[#42532])

Snapshot/Restore::
* Upgrade GCS Repository Dependencies {es-pull}43142[#43142]


",12401,True,3137.0867215549038,median
"[[jpa.repositories]]
= JPA Repositories

This chapter points out the specialties for repository support for JPA. This builds on the core repository support explained in ""`<<repositories>>`"". Make sure you have a sound understanding of the basic concepts explained there.

[[jpa.introduction]]
== Introduction

This section describes the basics of configuring Spring Data JPA through either:

* ""`<<jpa.namespace>>`"" (XML configuration)
* ""`<<jpa.java-config>>`"" (Java configuration)

[[jpa.namespace]]
=== Spring Namespace

The JPA module of Spring Data contains a custom namespace that allows defining repository beans. It also contains certain features and element attributes that are special to JPA. Generally, the JPA repositories can be set up by   using the `repositories` element, as shown in the following example:

.Setting up JPA repositories by using the namespace
====
[source, xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<beans xmlns=""http://www.springframework.org/schema/beans""
  xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance""
  xmlns:jpa=""http://www.springframework.org/schema/data/jpa""
  xsi:schemaLocation=""http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/data/jpa
    https://www.springframework.org/schema/data/jpa/spring-jpa.xsd"">

  <jpa:repositories base-package=""com.acme.repositories"" />

</beans>
----
====

Using the `repositories` element looks up Spring Data repositories as described in ""`<<repositories.create-instances>>`"". Beyond that, it activates persistence exception translation for all beans annotated with `@Repository`, to let exceptions being thrown by the JPA persistence providers be converted into Spring's `DataAccessException` hierarchy.

[[jpa.namespace.custom-namespace-attributes]]
==== Custom Namespace Attributes
Beyond the default attributes of the `repositories` element, the JPA namespace offers additional attributes to let you gain more detailed control over the setup of the repositories:

.Custom JPA-specific attributes of the `repositories` element
[options = ""autowidth""]
|===============
|`entity-manager-factory-ref`|Explicitly wire the `EntityManagerFactory` to be used with the repositories being detected by the `repositories` element. Usually used if multiple `EntityManagerFactory` beans are used within the application. If not configured, Spring Data automatically looks up the `EntityManagerFactory` bean with the name `entityManagerFactory` in the `ApplicationContext`.
|`transaction-manager-ref`|Explicitly wire the `PlatformTransactionManager` to be used with the repositories being detected by the `repositories` element. Usually only necessary if multiple transaction managers or `EntityManagerFactory` beans have been configured. Default to a single defined `PlatformTransactionManager` inside the current `ApplicationContext`.
|===============

NOTE: Spring Data JPA requires a `PlatformTransactionManager` bean named `transactionManager` to be present if no explicit `transaction-manager-ref` is defined.

[[jpa.java-config]]
=== Annotation-based Configuration
The Spring Data JPA repositories support can be activated not only through an XML namespace but also by using an annotation through JavaConfig, as shown in the following example:

.Spring Data JPA repositories using JavaConfig
====
[source, java]
----
@Configuration
@EnableJpaRepositories
@EnableTransactionManagement
class ApplicationConfig {

  @Bean
  public DataSource dataSource() {

    EmbeddedDatabaseBuilder builder = new EmbeddedDatabaseBuilder();
    return builder.setType(EmbeddedDatabaseType.HSQL).build();
  }

  @Bean
  public LocalContainerEntityManagerFactoryBean entityManagerFactory() {

    HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
    vendorAdapter.setGenerateDdl(true);

    LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
    factory.setJpaVendorAdapter(vendorAdapter);
    factory.setPackagesToScan(""com.acme.domain"");
    factory.setDataSource(dataSource());
    return factory;
  }

  @Bean
  public PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {

    JpaTransactionManager txManager = new JpaTransactionManager();
    txManager.setEntityManagerFactory(entityManagerFactory);
    return txManager;
  }
}
----
====
NOTE: You must create `LocalContainerEntityManagerFactoryBean` and not `EntityManagerFactory` directly, since the former also participates in exception translation mechanisms in addition to creating `EntityManagerFactory`.

The preceding configuration class sets up an embedded HSQL database by using the `EmbeddedDatabaseBuilder` API of `spring-jdbc`. Spring Data then sets up an `EntityManagerFactory` and uses Hibernate as the sample persistence provider. The last infrastructure component declared here is the `JpaTransactionManager`. Finally, the example activates Spring Data JPA repositories by using the `@EnableJpaRepositories` annotation, which essentially carries the same attributes as the XML namespace. If no base package is configured, it uses the one in which the configuration class resides.

[[jpa.bootstrap-mode]]
=== Bootstrap Mode

By default, Spring Data JPA repositories are default Spring beans.
They are singleton scoped and eagerly initialized.
During startup, they already interact with the JPA `EntityManager` for verification and metadata analysis purposes.
Spring Framework supports the initialization of the JPA `EntityManagerFactory` in a background thread because that process usually takes up a significant amount of startup time in a Spring application.
To make use of that background initialization effectively, we need to make sure that JPA repositories are initialized as late as possible.

As of Spring Data JPA 2.1 you can now configure a `BootstrapMode` (either via the `@EnableJpaRepositories` annotation or the XML namespace) that takes the following values:

* `DEFAULT` (default) -- Repositories are instantiated eagerly unless explicitly annotated with `@Lazy`.
The lazification only has effect if no client bean needs an instance of the repository as that will require the initialization of the repository bean.
* `LAZY` -- Implicitly declares all repository beans lazy and also causes lazy initialization proxies to be created to be injected into client beans.
That means, that repositories will not get instantiated if the client bean is simply storing the instance in a field and not making use of the repository during initialization.
Repository instances will be initialized and verified upon first interaction with the repository.
* `DEFERRED` -- Fundamentally the same mode of operation as `LAZY`, but triggering repository initialization in response to an `ContextRefreshedEvent` so that repositories are verified before the application has completely started.

[[jpa.bootstrap-mode.recommendations]]
==== Recommendations

If you're not using asynchronous JPA bootstrap stick with the default bootstrap mode.

In case you bootstrap JPA asynchronously, `DEFERRED` is a reasonable default as it will make sure the Spring Data JPA bootstrap only waits for the `EntityManagerFactory` setup if that itself takes longer than initializing all other application components.
Still, it makes sure that repositories are properly initialized and validated before the application signals it's up.

`LAZY` is a decent choice for testing scenarios and local development.
Once you are pretty sure that repositories can properly bootstrap, or in cases where you are testing other parts of the application, running verification for all repositories might unnecessarily increase the startup time.
The same applies to local development in which you only access parts of the application that might need to have a single repository initialized.

[[jpa.entity-persistence]]
== Persisting Entities

This section describes how to persist (save) entities with Spring Data JPA.

[[jpa.entity-persistence.saving-entites]]
=== Saving Entities

Saving an entity can be performed with the `CrudRepository.save(…)` method. It persists or merges the given entity by using the underlying JPA `EntityManager`. If the entity has not yet been persisted, Spring Data JPA saves the entity with a call to the `entityManager.persist(…)` method. Otherwise, it calls the `entityManager.merge(…)` method.

[[jpa.entity-persistence.saving-entites.strategies]]
==== Entity State-detection Strategies
Spring Data JPA offers the following strategies to detect whether an entity is new or not:

1. Version-Property and Id-Property inspection (*default*):
   By default Spring Data JPA inspects first if there is a Version-property of non-primitive type.
   If there is, the entity is considered new if the value of that property is `null`.
   Without such a Version-property Spring Data JPA inspects the identifier property of the given entity.
   If the identifier property is `null`, then the entity is assumed to be new.
   Otherwise, it is assumed to be not new.
2. Implementing `Persistable`: If an entity implements `Persistable`, Spring Data JPA delegates the new detection to the `isNew(…)` method of the entity. See the link:$$https://docs.spring.io/spring-data/data-commons/docs/current/api/index.html?org/springframework/data/domain/Persistable.html$$[JavaDoc] for details.
3. Implementing `EntityInformation`: You can customize the `EntityInformation` abstraction used in the `SimpleJpaRepository` implementation by creating a subclass of `JpaRepositoryFactory` and overriding the `getEntityInformation(…)` method accordingly. You then have to register the custom implementation of `JpaRepositoryFactory` as a Spring bean. Note that this should be rarely necessary. See the link:$$https://docs.spring.io/spring-data/data-jpa/docs/current/api/index.html?org/springframework/data/jpa/repository/support/JpaRepositoryFactory.html$$[JavaDoc] for details.

Option 1 is not an option for entities that use manually assigned identifiers as with those the identifier will always be non-`null`.
A common pattern in that scenario is to use a common base class with a transient flag defaulting to indicate a new instance and using JPA lifecycle callbacks to flip that flag on persistence operations:

.A base class for entities with manually assigned identifiers
====
[source, java]
----
@MappedSuperclass
public abstract class AbstractEntity<ID> implements Persistable<ID> {

  @Transient
  private boolean isNew = true; <1>

  @Override
  public boolean isNew() {
    return isNew; <2>
  }

  @PrePersist <3>
  @PostLoad
  void markNotNew() {
    this.isNew = false;
  }

  // More code…
}
----
<1> Declare a flag to hold the new state. Transient so that it's not persisted to the database.
<2> Return the flag in the implementation of `Persistable.isNew()` so that Spring Data repositories know whether to call `EntityManager.persist()` or `….merge()`.
<3> Declare a method using JPA entity callbacks so that the flag is switched to indicate an existing entity after a repository call to `save(…)` or an instance creation by the persistence provider.
====

[[jpa.query-methods]]
== Query Methods

This section describes the various ways to create a query with Spring Data JPA.

[[jpa.sample-app.finders.strategies]]
=== Query Lookup Strategies

The JPA module supports defining a query manually as a String or having it being derived from the method name.

Derived queries with the predicates `IsStartingWith`, `StartingWith`, `StartsWith`, `IsEndingWith`, `EndingWith`, `EndsWith`,
`IsNotContaining`, `NotContaining`, `NotContains`, `IsContaining`, `Containing`, `Contains` the respective arguments for these queries will get sanitized.
This means if the arguments actually contain characters recognized by `LIKE` as wildcards these will get escaped so they match only as literals.
The escape character used can be configured by setting the `escapeCharacter` of the `@EnableJpaRepositories` annotation.
Compare with <<jpa.query.spel-expressions>>.

[[jpa.query-methods.declared-queries]]
==== Declared Queries
Although getting a query derived from the method name is quite convenient, one might face the situation in which either the method name parser does not support the keyword one wants to use or the method name would get unnecessarily ugly. So you can either use JPA named queries through a naming convention (see <<jpa.query-methods.named-queries>> for more information) or rather annotate your query method with `@Query` (see <<jpa.query-methods.at-query>> for details).

[[jpa.query-methods.query-creation]]
=== Query Creation

Generally, the query creation mechanism for JPA works as described in ""`<<repositories.query-methods>>`"". The following example shows what a JPA query method translates into:

.Query creation from method names
====
----
public interface UserRepository extends Repository<User, Long> {

  List<User> findByEmailAddressAndLastname(String emailAddress, String lastname);
}
----
We create a query using the JPA criteria API from this, but, essentially, this translates into the following query: `select u from User u where u.emailAddress = ?1 and u.lastname = ?2`. Spring Data JPA does a property check and traverses nested properties, as described in ""`<<repositories.query-methods.query-property-expressions>>`"".
====

The following table describes the keywords supported for JPA and what a method containing that keyword translates to:

.Supported keywords inside method names
[options = ""header, autowidth""]
|===============
|Keyword|Sample|JPQL snippet
|`Distinct`|`findDistinctByLastnameAndFirstname`|`select distinct ... where x.lastname = ?1 and x.firstname = ?2`
|`And`|`findByLastnameAndFirstname`|`… where x.lastname = ?1 and x.firstname = ?2`
|`Or`|`findByLastnameOrFirstname`|`… where x.lastname = ?1 or x.firstname = ?2`
|`Is`, `Equals`|`findByFirstname`,`findByFirstnameIs`,`findByFirstnameEquals`|`… where x.firstname = ?1`
|`Between`|`findByStartDateBetween`|`… where x.startDate between ?1 and ?2`
|`LessThan`|`findByAgeLessThan`|`… where x.age < ?1`
|`LessThanEqual`|`findByAgeLessThanEqual`|`… where x.age \\<= ?1`
|`GreaterThan`|`findByAgeGreaterThan`|`… where x.age > ?1`
|`GreaterThanEqual`|`findByAgeGreaterThanEqual`|`… where x.age >= ?1`
|`After`|`findByStartDateAfter`|`… where x.startDate > ?1`
|`Before`|`findByStartDateBefore`|`… where x.startDate < ?1`
|`IsNull`, `Null`|`findByAge(Is)Null`|`… where x.age is null`
|`IsNotNull`, `NotNull`|`findByAge(Is)NotNull`|`… where x.age not null`
|`Like`|`findByFirstnameLike`|`… where x.firstname like ?1`
|`NotLike`|`findByFirstnameNotLike`|`… where x.firstname not like ?1`
|`StartingWith`|`findByFirstnameStartingWith`|`… where x.firstname like ?1` (parameter bound with appended `%`)
|`EndingWith`|`findByFirstnameEndingWith`|`… where x.firstname like ?1` (parameter bound with prepended `%`)
|`Containing`|`findByFirstnameContaining`|`… where x.firstname like ?1` (parameter bound wrapped in `%`)
|`OrderBy`|`findByAgeOrderByLastnameDesc`|`… where x.age = ?1 order by x.lastname desc`
|`Not`|`findByLastnameNot`|`… where x.lastname <> ?1`
|`In`|`findByAgeIn(Collection<Age> ages)`|`… where x.age in ?1`
|`NotIn`|`findByAgeNotIn(Collection<Age> ages)`|`… where x.age not in ?1`
|`True`|`findByActiveTrue()`|`… where x.active = true`
|`False`|`findByActiveFalse()`|`… where x.active = false`
|`IgnoreCase`|`findByFirstnameIgnoreCase`|`… where UPPER(x.firstname) = UPPER(?1)`
|===============

NOTE: `In` and `NotIn` also take any subclass of `Collection` as a parameter as well as arrays or varargs. For other syntactical versions of the same logical operator, check ""`<<repository-query-keywords>>`"".

[[jpa.query-methods.named-queries]]
=== Using JPA Named Queries

NOTE: The examples use the `<named-query />` element and `@NamedQuery` annotation. The queries for these configuration elements have to be defined in the JPA query language. Of course, you can use `<named-native-query />` or `@NamedNativeQuery` too. These elements let you define the query in native SQL by losing the database platform independence.

[[jpa.query-methods.named-queries.xml-named-query-definition]]
==== XML Named Query Definition
To use XML configuration, add the necessary `<named-query />` element to the `orm.xml` JPA configuration file located in the `META-INF` folder of your classpath. Automatic invocation of named queries is enabled by using some defined naming convention. For more details, see below.

.XML named query configuration
====
[source, xml]
----
<named-query name=""User.findByLastname"">
  <query>select u from User u where u.lastname = ?1</query>
</named-query>
----
====

The query has a special name that is used to resolve it at runtime.

[[jpa.query-methods.named-queries.annotation-based-configuration]]
==== Annotation-based Configuration
Annotation-based configuration has the advantage of not needing another configuration file to be edited, lowering maintenance effort. You pay for that benefit by the need to recompile your domain class for every new query declaration.

.Annotation-based named query configuration
====
[source, java]
----
@Entity
@NamedQuery(name = ""User.findByEmailAddress"",
  query = ""select u from User u where u.emailAddress = ?1"")
public class User {

}
----
====

[[jpa.query-methods.named-queries.declaring-interfaces]]
==== Declaring Interfaces
To allow these named queries, specify the `UserRepository` as follows:

.Query method declaration in UserRepository
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  List<User> findByLastname(String lastname);

  User findByEmailAddress(String emailAddress);
}
----
====

Spring Data tries to resolve a call to these methods to a named query, starting with the simple name of the configured domain class, followed by the method name separated by a dot.
So the preceding example would use the named queries defined earlier instead of trying to create a query from the method name.

[[jpa.query-methods.at-query]]
=== Using `@Query`

Using named queries to declare queries for entities is a valid approach and works fine for a small number of queries. As the queries themselves are tied to the Java method that runs them, you can actually bind them directly by using the Spring Data JPA `@Query` annotation rather than annotating them to the domain class. This frees the domain class from persistence specific information and co-locates the query to the repository interface.

Queries annotated to the query method take precedence over queries defined using `@NamedQuery` or named queries declared in `orm.xml`.

The following example shows a query created with the `@Query` annotation:

.Declare query at the query method using `@Query`
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.emailAddress = ?1"")
  User findByEmailAddress(String emailAddress);
}
----
====

[[jpa.query-methods.at-query.advanced-like]]
==== Using Advanced `LIKE` Expressions

The query running mechanism for manually defined queries created with `@Query` allows the definition of advanced `LIKE` expressions inside the query definition, as shown in the following example:

.Advanced `like` expressions in @Query
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.firstname like %?1"")
  List<User> findByFirstnameEndsWith(String firstname);
}
----
====

In the preceding example, the `LIKE` delimiter character (`%`) is recognized, and the query is transformed into a valid JPQL query (removing the `%`). Upon running the query, the parameter passed to the method call gets augmented with the previously recognized `LIKE` pattern.

[[jpa.query-methods.at-query.native]]
==== Native Queries

The `@Query` annotation allows for running native queries by setting the `nativeQuery` flag to true, as shown in the following example:

.Declare a native query at the query method using @Query
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(value = ""SELECT * FROM USERS WHERE EMAIL_ADDRESS = ?1"", nativeQuery = true)
  User findByEmailAddress(String emailAddress);
}
----

====

NOTE: Spring Data JPA does not currently support dynamic sorting for native queries, because it would have to manipulate the actual query declared, which it cannot do reliably for native SQL. You can, however, use native queries for pagination by specifying the count query yourself, as shown in the following example:

.Declare native count queries for pagination at the query method by using `@Query`
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(value = ""SELECT * FROM USERS WHERE LASTNAME = ?1"",
    countQuery = ""SELECT count(*) FROM USERS WHERE LASTNAME = ?1"",
    nativeQuery = true)
  Page<User> findByLastname(String lastname, Pageable pageable);
}
----

====

A similar approach also works with named native queries, by adding the `.count` suffix to a copy of your query. You probably need to register a result set mapping for your count query, though.

[[jpa.query-methods.sorting]]
=== Using Sort

Sorting can be done by either providing a `PageRequest` or by using `Sort` directly. The properties actually used within the `Order` instances of `Sort` need to match your domain model, which means they need to resolve to either a property or an alias used within the query. The JPQL defines this as a state field path expression.

NOTE: Using any non-referenceable path expression leads to an `Exception`.

However, using `Sort` together with <<jpa.query-methods.at-query, `@Query`>> lets you sneak in non-path-checked `Order` instances containing functions within the `ORDER BY` clause. This is possible because the `Order` is appended to the given query string. By default, Spring Data JPA rejects any `Order` instance containing function calls, but you can use `JpaSort.unsafe` to add potentially unsafe ordering.

The following example uses `Sort` and `JpaSort`, including an unsafe option on `JpaSort`:

.Using `Sort` and `JpaSort`
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.lastname like ?1%"")
  List<User> findByAndSort(String lastname, Sort sort);

  @Query(""select u.id, LENGTH(u.firstname) as fn_len from User u where u.lastname like ?1%"")
  List<Object[]> findByAsArrayAndSort(String lastname, Sort sort);
}

repo.findByAndSort(""lannister"", Sort.by(""firstname""));                <1>
repo.findByAndSort(""stark"", Sort.by(""LENGTH(firstname)""));            <2>
repo.findByAndSort(""targaryen"", JpaSort.unsafe(""LENGTH(firstname)"")); <3>
repo.findByAsArrayAndSort(""bolton"", Sort.by(""fn_len""));               <4>
----
<1> Valid `Sort` expression pointing to property in domain model.
<2> Invalid `Sort` containing function call. Throws Exception.
<3> Valid `Sort` containing explicitly _unsafe_ `Order`.
<4> Valid `Sort` expression pointing to aliased function.
====

[[jpa.named-parameters]]
=== Using Named Parameters

By default, Spring Data JPA uses position-based parameter binding, as described in all the preceding examples. This makes query methods a little error-prone when refactoring regarding the parameter position. To solve this issue, you can use `@Param` annotation to give a method parameter a concrete name and bind the name in the query, as shown in the following example:

.Using named parameters
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.firstname = :firstname or u.lastname = :lastname"")
  User findByLastnameOrFirstname(@Param(""lastname"") String lastname,
                                 @Param(""firstname"") String firstname);
}
----
====

NOTE: The method parameters are switched according to their order in the defined query.

NOTE: As of version 4, Spring fully supports Java 8’s parameter name discovery based on the `-parameters` compiler flag. By using this flag in your build as an alternative to debug information, you can omit the `@Param` annotation for named parameters.

[[jpa.query.spel-expressions]]
=== Using SpEL Expressions

As of Spring Data JPA release 1.4, we support the usage of restricted SpEL template expressions in manually defined queries that are defined with `@Query`. Upon the query being run, these expressions are evaluated against a predefined set of variables. Spring Data JPA supports a variable called `entityName`. Its usage is `select x from #{#entityName} x`. It inserts the `entityName` of the domain type associated with the given repository. The `entityName` is resolved as follows: If the domain type has set the name property on the `@Entity` annotation, it is used. Otherwise, the simple class-name of the domain type is used.

The following example demonstrates one use case for the `+#{#entityName}+` expression in a query string where you want to define a repository interface with a query method and a manually defined query:

.Using SpEL expressions in repository query methods - entityName
====
[source, java]
----
@Entity
public class User {

  @Id
  @GeneratedValue
  Long id;

  String lastname;
}

public interface UserRepository extends JpaRepository<User,Long> {

  @Query(""select u from #{#entityName} u where u.lastname = ?1"")
  List<User> findByLastname(String lastname);
}
----
====

To avoid stating the actual entity name in the query string of a `@Query` annotation, you can use the `+#{#entityName}+` variable.

NOTE: The `entityName` can be customized by using the `@Entity` annotation. Customizations in `orm.xml` are not supported for the SpEL expressions.

Of course, you could have just used `User` in the query declaration directly, but that would require you to change the query as well. The reference to `#entityName` picks up potential future remappings of the `User` class to a different entity name (for example, by using `@Entity(name = ""MyUser"")`.

Another use case for the `#{#entityName}` expression in a query string is if you want to define a generic repository interface with specialized repository interfaces for a concrete domain type. To not repeat the definition of custom query methods on the concrete interfaces, you can use the entity name expression in the query string of the `@Query` annotation in the generic repository interface, as shown in the following example:

.Using SpEL expressions in repository query methods - entityName with inheritance
====
[source, java]
----
@MappedSuperclass
public abstract class AbstractMappedType {
  …
  String attribute
}

@Entity
public class ConcreteType extends AbstractMappedType { … }

@NoRepositoryBean
public interface MappedTypeRepository<T extends AbstractMappedType>
  extends Repository<T, Long> {

  @Query(""select t from #{#entityName} t where t.attribute = ?1"")
  List<T> findAllByAttribute(String attribute);
}

public interface ConcreteRepository
  extends MappedTypeRepository<ConcreteType> { … }
----
====

In the preceding example, the `MappedTypeRepository` interface is the common parent interface for a few domain types extending `AbstractMappedType`. It also defines the generic `findAllByAttribute(…)` method, which can be used on instances of the specialized repository interfaces. If you now invoke `findByAllAttribute(…)` on `ConcreteRepository`, the query becomes `select t from ConcreteType t where t.attribute = ?1`.

SpEL expressions to manipulate arguments may also be used to manipulate method arguments.
In these SpEL expressions the entity name is not available, but the arguments are.
They can be accessed by name or index as demonstrated in the following example.

.Using SpEL expressions in repository query methods - accessing arguments.
====
[source, java]
----
@Query(""select u from User u where u.firstname = ?1 and u.firstname=?#{[0]} and u.emailAddress = ?#{principal.emailAddress}"")
List<User> findByFirstnameAndCurrentUserWithCustomQuery(String firstname);
----
====

For `like`-conditions one often wants to append `%` to the beginning or the end of a String valued parameter.
This can be done by appending or prefixing a bind parameter marker or a SpEL expression with `%`.
Again the following example demonstrates this.

.Using SpEL expressions in repository query methods - wildcard shortcut.
====
[source, java]
----
@Query(""select u from User u where u.lastname like %:#{[0]}% and u.lastname like %:lastname%"")
List<User> findByLastnameWithSpelExpression(@Param(""lastname"") String lastname);
----
====

When using `like`-conditions with values that are coming from a not secure source the values should be sanitized so they can't contain any wildcards and thereby allow attackers to select more data than they should be able to.
For this purpose the `escape(String)` method is made available in the SpEL context.
It prefixes all instances of `_` and `%` in the first argument with the single character from the second argument.
In combination with the `escape` clause of the `like` expression available in JPQL and standard SQL this allows easy cleaning of bind parameters.


.Using SpEL expressions in repository query methods - sanitizing input values.
====
[source, java]
----
@Query(""select u from User u where u.firstname like %?#{escape([0])}% escape ?#{escapeCharacter()}"")
List<User> findContainingEscaped(String namePart);
----
====

Given this method declaration in a repository interface `findContainingEscaped(""Peter_"")` will find `Peter_Parker` but not `Peter Parker`.
The escape character used can be configured by setting the `escapeCharacter` of the `@EnableJpaRepositories` annotation.
Note that the method `escape(String)` available in the SpEL context will only escape the SQL and JPQL standard wildcards `_` and `%`.
If the underlying database or the JPA implementation supports additional wildcards these will not get escaped.

[[jpa.modifying-queries]]
=== Modifying Queries

All the previous sections describe how to declare queries to access a given entity or collection of entities.
You can add custom modifying behavior by using the custom method facilities described in ""`<<repositories.custom-implementations>>`"".
As this approach is feasible for comprehensive custom functionality, you can modify queries that only need parameter binding by annotating the query method with `@Modifying`, as shown in the following example:

.Declaring manipulating queries
====
[source, java]
----
@Modifying
@Query(""update User u set u.firstname = ?1 where u.lastname = ?2"")
int setFixedFirstnameFor(String firstname, String lastname);
----
====

Doing so triggers the query annotated to the method as an updating query instead of a selecting one. As the `EntityManager` might contain outdated entities after the execution of the modifying query, we do not automatically clear it (see the https://docs.oracle.com/javaee/7/api/javax/persistence/EntityManager.html[JavaDoc] of `EntityManager.clear()` for details), since this effectively drops all non-flushed changes still pending in the `EntityManager`.
If you wish the `EntityManager` to be cleared automatically, you can set the `@Modifying` annotation's `clearAutomatically` attribute to `true`.

The `@Modifying` annotation is only relevant in combination with the `@Query` annotation.
Derived query methods or custom methods do not require this annotation.

[[jpa.modifying-queries.derived-delete]]
==== Derived Delete Queries
Spring Data JPA also supports derived delete queries that let you avoid having to declare the JPQL query explicitly, as shown in the following example:

.Using a derived delete query
====
[source, java]
----
interface UserRepository extends Repository<User, Long> {

  void deleteByRoleId(long roleId);

  @Modifying
  @Query(""delete from User u where u.role.id = ?1"")
  void deleteInBulkByRoleId(long roleId);
}
----
====

Although the `deleteByRoleId(…)` method looks like it basically produces the same result as the `deleteInBulkByRoleId(…)`, there is an important difference between the two method declarations in terms of the way they are run.
As the name suggests, the latter method issues a single JPQL query (the one defined in the annotation) against the database.
This means even currently loaded instances of `User` do not see lifecycle callbacks invoked.

To make sure lifecycle queries are actually invoked, an invocation of `deleteByRoleId(…)` runs a query and then deletes the returned instances one by one, so that the persistence provider can actually invoke `@PreRemove` callbacks on those entities.

In fact, a derived delete query is a shortcut for running the query and then calling `CrudRepository.delete(Iterable<User> users)` on the result and keeping behavior in sync with the implementations of other `delete(…)` methods in `CrudRepository`.

[[jpa.query-hints]]
=== Applying Query Hints
To apply JPA query hints to the queries declared in your repository interface, you can use the `@QueryHints` annotation. It takes an array of JPA `@QueryHint` annotations plus a boolean flag to potentially disable the hints applied to the additional count query triggered when applying pagination, as shown in the following example:

.Using QueryHints with a repository method
====
[source, java]
----
public interface UserRepository extends Repository<User, Long> {

  @QueryHints(value = { @QueryHint(name = ""name"", value = ""value"")},
              forCounting = false)
  Page<User> findByLastname(String lastname, Pageable pageable);
}
----
====
The preceding declaration would apply the configured `@QueryHint` for that actually query but omit applying it to the count query triggered to calculate the total number of pages.

[[jpa.entity-graph]]
=== Configuring Fetch- and LoadGraphs

The JPA 2.1 specification introduced support for specifying Fetch- and LoadGraphs that we also support with the `@EntityGraph` annotation, which lets you reference a `@NamedEntityGraph` definition. You can use that annotation on an entity to configure the fetch plan of the resulting query. The type (`Fetch` or `Load`) of the fetching can be configured by using the `type` attribute on the `@EntityGraph` annotation. See the JPA 2.1 Spec 3.7.4 for further reference.

The following example shows how to define a named entity graph on an entity:

.Defining a named entity graph on an entity.
====
[source, java]
----
@Entity
@NamedEntityGraph(name = ""GroupInfo.detail"",
  attributeNodes = @NamedAttributeNode(""members""))
public class GroupInfo {

  // default fetch mode is lazy.
  @ManyToMany
  List<GroupMember> members = new ArrayList<GroupMember>();

  …
}
----
====

The following example shows how to reference a named entity graph on a repository query method:

.Referencing a named entity graph definition on a repository query method.
====
[source, java]
----
@Repository
public interface GroupRepository extends CrudRepository<GroupInfo, String> {

  @EntityGraph(value = ""GroupInfo.detail"", type = EntityGraphType.LOAD)
  GroupInfo getByGroupName(String name);

}
----
====

It is also possible to define ad hoc entity graphs by using `@EntityGraph`. The provided `attributePaths` are translated into the according `EntityGraph` without needing to explicitly add `@NamedEntityGraph` to your domain types, as shown in the following example:

.Using AD-HOC entity graph definition on an repository query method.
====
[source, java]
----
@Repository
public interface GroupRepository extends CrudRepository<GroupInfo, String> {

  @EntityGraph(attributePaths = { ""members"" })
  GroupInfo getByGroupName(String name);

}
----
====


include::{spring-data-commons-docs}/repository-projections.adoc[leveloffset=+2]

[[jpa.stored-procedures]]
== Stored Procedures
The JPA 2.1 specification introduced support for calling stored procedures by using the JPA criteria query API.
We Introduced the `@Procedure` annotation for declaring stored procedure metadata on a repository method.

The examples to follow use the following stored procedure:

.The definition of the `plus1inout` procedure in HSQL DB.
====
[source, sql]
----
/;
DROP procedure IF EXISTS plus1inout
/;
CREATE procedure plus1inout (IN arg int, OUT res int)
BEGIN ATOMIC
 set res = arg + 1;
END
/;
----
====

Metadata for stored procedures can be configured by using the `NamedStoredProcedureQuery` annotation on an entity type.

[[jpa.stored-procedure-entity-metadata]]
.StoredProcedure metadata definitions on an entity.
====
[source, java]
----
@Entity
@NamedStoredProcedureQuery(name = ""User.plus1"", procedureName = ""plus1inout"", parameters = {
  @StoredProcedureParameter(mode = ParameterMode.IN, name = ""arg"", type = Integer.class),
  @StoredProcedureParameter(mode = ParameterMode.OUT, name = ""res"", type = Integer.class) })
public class User {}
----
====

Note that `@NamedStoredProcedureQuery` has two different names for the stored procedure.
`name` is the name JPA uses. `procedureName` is the name the stored procedure has in the database.

You can reference stored procedures from a repository method in multiple ways.
The stored procedure to be called can either be defined directly by using the `value` or `procedureName` attribute of the `@Procedure` annotation.
This refers directly to the stored procedure in the database and ignores any configuration via `@NamedStoredProcedureQuery`.

Alternatively you may specify the `@NamedStoredProcedureQuery.name` attribute as the `@Procedure.name` attribute.
If neither `value`, `procedureName` nor `name` is configured, the name of the repository method is used as the `name` attribute.

The following example shows how to reference an explicitly mapped procedure:

[[jpa.stored-procedure-reference]]
.Referencing explicitly mapped procedure with name ""plus1inout"" in database.
====
[source, java]
----
@Procedure(""plus1inout"")
Integer explicitlyNamedPlus1inout(Integer arg);
----
====

The following example is equivalent to the previous one but uses the `procedureName` alias:

.Referencing implicitly mapped procedure with name ""plus1inout"" in database via `procedureName` alias.
====
[source, java]
----
@Procedure(procedureName = ""plus1inout"")
Integer callPlus1InOut(Integer arg);
----
====

The following is again equivalent to the previous two but using the method name instead of an explicite annotation attribute.

.Referencing implicitly mapped named stored procedure ""User.plus1"" in `EntityManager` by using the method name.
====
[source, java]
----
@Procedure
Integer plus1inout(@Param(""arg"") Integer arg);
----
====

The following example shows how to reference a stored procedure by referencing the `@NamedStoredProcedureQuery.name` attribute.

.Referencing explicitly mapped named stored procedure ""User.plus1IO"" in `EntityManager`.
====
[source, java]
----
@Procedure(name = ""User.plus1IO"")
Integer entityAnnotatedCustomNamedProcedurePlus1IO(@Param(""arg"") Integer arg);
----
====

If the stored procedure getting called has a single out parameter that parameter may be returned as the return value of the method.
If there are multiple out parameters specified in a `@NamedStoredProcedureQuery` annotation those can be returned as a `Map` with the key being the parameter name given in the `@NamedStoredProcedureQuery` annotation.


[[specifications]]
== Specifications

JPA 2 introduces a criteria API that you can use to build queries programmatically. By writing a `criteria`, you define the where clause of a query for a domain class. Taking another step back, these criteria can be regarded as a predicate over the entity that is described by the JPA criteria API constraints.

Spring Data JPA takes the concept of a specification from Eric Evans' book, ""`Domain Driven Design`"", following the same semantics and providing an API to define such specifications with the JPA criteria API. To support specifications, you can extend your repository interface with the `JpaSpecificationExecutor` interface, as follows:

[source, java]
----
public interface CustomerRepository extends CrudRepository<Customer, Long>, JpaSpecificationExecutor<Customer> {
 …
}
----

The additional interface has methods that let you run specifications in a variety of ways. For example, the `findAll` method returns all entities that match the specification, as shown in the following example:

[source, java]
----
List<T> findAll(Specification<T> spec);
----

The `Specification` interface is defined as follows:

[source, java]
----
public interface Specification<T> {
  Predicate toPredicate(Root<T> root, CriteriaQuery<?> query,
            CriteriaBuilder builder);
}
----

Specifications can easily be used to build an extensible set of predicates on top of an entity that then can be combined and used with `JpaRepository` without the need to declare a query (method) for every needed combination, as shown in the following example:

.Specifications for a Customer
====
[source, java]
----
public class CustomerSpecs {


  public static Specification<Customer> isLongTermCustomer() {
    return (root, query, builder) -> {
      LocalDate date = LocalDate.now().minusYears(2);
      return builder.lessThan(root.get(Customer_.createdAt), date);
    };
  }

  public static Specification<Customer> hasSalesOfMoreThan(MonetaryAmount value) {
    return (root, query, builder) -> {
      // build query here
    };
  }
}
----
====

The `Customer_` type is a metamodel type generated using the JPA Metamodel generator (see the link:$$https://docs.jboss.org/hibernate/jpamodelgen/1.0/reference/en-US/html_single/#whatisit$$[Hibernate implementation's documentation for an example]).
So the expression, `Customer_.createdAt`, assumes the `Customer` has a `createdAt` attribute of type `Date`.
Besides that, we have expressed some criteria on a business requirement abstraction level and created executable `Specifications`.
So a client might use a `Specification` as follows:

.Using a simple Specification
====
[source, java]
----
List<Customer> customers = customerRepository.findAll(isLongTermCustomer());
----
====

Why not create a query for this kind of data access? Using a single `Specification` does not gain a lot of benefit over a plain query declaration. The power of specifications really shines when you combine them to create new `Specification` objects. You can achieve this through the default methods of `Specification` we provide to build expressions similar to the following:

.Combined Specifications
====
[source, java]
----
MonetaryAmount amount = new MonetaryAmount(200.0, Currencies.DOLLAR);
List<Customer> customers = customerRepository.findAll(
  isLongTermCustomer().or(hasSalesOfMoreThan(amount)));
----

`Specification` offers some ""`glue-code`"" default methods to chain and combine `Specification` instances. These methods let you extend your data access layer by creating new `Specification` implementations and combining them with already existing implementations.
====

include::{spring-data-commons-docs}/query-by-example.adoc[leveloffset=+1]
include::query-by-example.adoc[leveloffset=+1]

[[transactions]]
== Transactionality

By default, CRUD methods on repository instances 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();
  }
}
----
",12084,False,2002.4984780512643,median
"#pragma once
/**
	@file
	@brief elliptic curve
	@author MITSUNARI Shigeo(@herumi)
	@license modified new BSD license
	http://opensource.org/licenses/BSD-3-Clause
*/
#include <stdlib.h>
#include <mcl/fp.hpp>
#include <mcl/ecparam.hpp>
#include <mcl/window_method.hpp>

#ifdef _MSC_VER
	#pragma warning(push)
	#pragma warning(disable : 4458)
#endif
#ifdef MCL_USE_OMP
#include <omp.h>
#endif

namespace mcl {

template<class _Fp> class Fp2T;

namespace local {

template<class Ec, class Vec>
void addTbl(Ec& Q, const Ec *tbl, const Vec& naf, size_t i)
{
	if (i >= naf.size()) return;
	int n = naf[i];
	if (n > 0) {
		Q += tbl[(n - 1) >> 1];
	} else if (n < 0) {
		Q -= tbl[(-n - 1) >> 1];
	}
}

} // mcl::local

namespace ec {

enum Mode {
	Jacobi = 0,
	Proj = 1,
	Affine
};

enum ModeCoeffA {
	Zero,
	Minus3,
	GenericA
};

namespace local {

/*
	elliptic class E must have
	member variables of type Fp x, y, z
	static member a_, b_, specialA_
*/
// x is negative <=> x < half(:=(p+1)/2) <=> a = 1
template<class F>
bool get_a_flag(const F& x)
{
	return x.isNegative();
}

// Im(x) is negative <=> Im(x)  < half(:=(p+1)/2) <=> a = 1

template<class F>
bool get_a_flag(const mcl::Fp2T<F>& x)
{
	return get_a_flag(x.b); // x = a + bi
}

/*
	Q = x P
	splitN = 2(G1) or 4(G2)
	w : window size
*/
template<class GLV, class G, class F, int splitN, size_t w>
void mul1CT(G& Q, const G& P, const mpz_class& x)
{
	const mpz_class& r = F::getOp().mp;
	const size_t tblSize = 1 << w;
	G tbl[splitN][tblSize];
	bool negTbl[splitN];
	mpz_class u[splitN];
	mpz_class y;
	F::getOp().modp.modp(y, x);
	if (y < 0) {
		y += r;
	}
	GLV::split(u, y);
	for (int i = 0; i < splitN; i++) {
		if (u[i] < 0) {
			gmp::neg(u[i], u[i]);
			negTbl[i] = true;
		} else {
			negTbl[i] = false;
		}
		tbl[i][0].clear();
	}
	tbl[0][1] = P;
	for (size_t j = 2; j < tblSize; j++) {
		G::add(tbl[0][j], tbl[0][j - 1], P);
	}
	for (int i = 1; i < splitN; i++) {
		for (size_t j = 1; j < tblSize; j++) {
			GLV::mulLambda(tbl[i][j], tbl[i - 1][j]);
		}
	}
	for (int i = 0; i < splitN; i++) {
		if (negTbl[i]) {
			for (size_t j = 0; j < tblSize; j++) {
				G::neg(tbl[i][j], tbl[i][j]);
			}
		}
	}
	mcl::FixedArray<uint8_t, sizeof(F) * 8 / w + 1> vTbl[splitN];
	size_t bitSizeTbl[splitN];
	size_t maxBitSize = 0;
	for (size_t i = 0; i < splitN; i++) {
		size_t bitSize = gmp::getBitSize(u[i]);
		bitSizeTbl[i] = bitSize;
		if (bitSize > maxBitSize) {
			maxBitSize = bitSize;
		}
	}
	size_t loopN = (maxBitSize + w - 1) / w;
	for (int i = 0; i < splitN; i++) {
		fp::ArrayIterator<fp::Unit> itr(gmp::getUnit(u[i]), bitSizeTbl[i], w);
		bool b = vTbl[i].resize(loopN);
		assert(b);
		(void)b;
		for (size_t j = 0; j < loopN; j++) {
			vTbl[i][loopN - 1 - j] = (uint8_t)itr.getNext();
		}
	}
	Q.clear();
	for (size_t k = 0; k < loopN; k++) {
		for (size_t i = 0; i < w; i++) {
			G::dbl(Q, Q);
		}
		for (size_t i = 0; i < splitN; i++) {
			uint8_t v = vTbl[i][k];
			G::add(Q, Q, tbl[i][v]);
		}
	}
}

/*
	z += xVec[i] * yVec[i] for i = 0, ..., min(N, n)
	splitN = 2(G1) or 4(G2)
	w : window size
*/
template<class GLV, class G, class F, int splitN, int w, size_t N>
static size_t mulVecNGLVT(G& z, const G *xVec, const mpz_class *yVec, size_t n)
{
	const mpz_class& r = F::getOp().mp;
	const size_t tblSize = 1 << (w - 2);
	typedef mcl::FixedArray<int8_t, sizeof(F) * 8 / splitN + splitN> NafArray;
	NafArray naf[N][splitN];
	G tbl[N][splitN][tblSize];
	bool b;
	mpz_class u[splitN], y;
	size_t maxBit = 0;

	if (n > N) n = N;
	for (size_t i = 0; i < n; i++) {
		y = yVec[i];
		y %= r;
		if (y < 0) {
			y += r;
		}
		GLV::split(u, y);

		for (int j = 0; j < splitN; j++) {
			gmp::getNAFwidth(&b, naf[i][j], u[j], w);
			assert(b); (void)b;
			if (naf[i][j].size() > maxBit) maxBit = naf[i][j].size();
		}

		G P2;
		G::dbl(P2, xVec[i]);
		tbl[i][0][0] = xVec[i];
		for (int k = 1; k < splitN; k++) {
			GLV::mulLambda(tbl[i][k][0], tbl[i][k - 1][0]);
		}
		for (size_t j = 1; j < tblSize; j++) {
			G::add(tbl[i][0][j], tbl[i][0][j - 1], P2);
			for (int k = 1; k < splitN; k++) {
				GLV::mulLambda(tbl[i][k][j], tbl[i][k - 1][j]);
			}
		}
	}
	z.clear();
	for (size_t i = 0; i < maxBit; i++) {
		const size_t bit = maxBit - 1 - i;
		G::dbl(z, z);
		for (size_t j = 0; j < n; j++) {
			for (int k = 0; k < splitN; k++) {
				mcl::local::addTbl(z, tbl[j][k], naf[j][k], bit);
			}
		}
	}
	return n;
}

} // mcl::ec::local

template<class E>
void normalizeJacobi(E& P)
{
	typedef typename E::Fp F;
	if (P.z.isZero()) return;
	F::inv(P.z, P.z);
	F rz2;
	F::sqr(rz2, P.z);
	P.x *= rz2;
	P.y *= rz2;
	P.y *= P.z;
	P.z = 1;
}

// (x/z^2, y/z^3)
template<class E>
bool isEqualJacobi(const E& P1, const E& P2)
{
	typedef typename E::Fp F;
	bool zero1 = P1.isZero();
	bool zero2 = P2.isZero();
	if (zero1) {
		return zero2;
	}
	if (zero2) return false;
	F s1, s2, t1, t2;
	F::sqr(s1, P1.z);
	F::sqr(s2, P2.z);
	F::mul(t1, P1.x, s2);
	F::mul(t2, P2.x, s1);
	if (t1 != t2) return false;
	F::mul(t1, P1.y, s2);
	F::mul(t2, P2.y, s1);
	t1 *= P2.z;
	t2 *= P1.z;
	return t1 == t2;
}

// Y^2 == X(X^2 + aZ^4) + bZ^6
template<class E>
bool isValidJacobi(const E& P)
{
	typedef typename E::Fp F;
	F y2, x2, z2, z4, t;
	F::sqr(x2, P.x);
	F::sqr(y2, P.y);
	F::sqr(z2, P.z);
	F::sqr(z4, z2);
	F::mul(t, z4, E::a_);
	t += x2;
	t *= P.x;
	z4 *= z2;
	z4 *= E::b_;
	t += z4;
	return y2 == t;
}

/*
	M > S + A
	a = 0   2M + 5S + 14A
	a = -3  2M + 7S + 15A
	generic 3M + 7S + 15A
	M == S
	a = 0   3M + 4S + 13A
	a = -3  3M + 6S + 14A
	generic 4M + 6S + 14A
*/
template<class E>
void dblJacobi(E& R, const E& P)
{
	typedef typename E::Fp F;
	if (P.isZero()) {
		R.clear();
		return;
	}
	const bool isPzOne = P.z.isOne();
	F x2, y2, xy, t;
	F::sqr(x2, P.x);
	F::sqr(y2, P.y);
	if (sizeof(F) <= 32) { // M == S
		F::mul(xy, P.x, y2);
		xy += xy;
		F::sqr(y2, y2);
	} else { // M > S + A
		F::add(xy, P.x, y2);
		F::sqr(y2, y2);
		F::sqr(xy, xy);
		xy -= x2;
		xy -= y2;
	}
	xy += xy; // 4xy^2
	switch (E::specialA_) {
	case Zero:
		F::mul2(t, x2);
		x2 += t;
		break;
	case Minus3:
		if (isPzOne) {
			x2 -= P.z;
		} else {
			F::sqr(t, P.z);
			F::sqr(t, t);
			x2 -= t;
		}
		F::mul2(t, x2);
		x2 += t;
		break;
	case GenericA:
	default:
		if (isPzOne) {
			t = E::a_;
		} else {
			F::sqr(t, P.z);
			F::sqr(t, t);
			t *= E::a_;
		}
		t += x2;
		F::mul2(x2, x2);
		x2 += t;
		break;
	}
	F::sqr(R.x, x2);
	R.x -= xy;
	R.x -= xy;
	if (isPzOne) {
		R.z = P.y;
	} else {
		F::mul(R.z, P.y, P.z);
	}
	F::mul2(R.z, R.z);
	F::sub(R.y, xy, R.x);
	R.y *= x2;
	F::mul2(y2, y2);
	F::mul2(y2, y2);
	F::mul2(y2, y2);
	R.y -= y2;
}

// 7M + 4S + 7A
template<class E>
void addJacobi(E& R, const E& P, const E& Q)
{
	typedef typename E::Fp F;
	if (P.isZero()) { R = Q; return; }
	if (Q.isZero()) { R = P; return; }
	bool isPzOne = P.z.isOne();
	bool isQzOne = Q.z.isOne();
	F r, U1, S1, H, H3;
	if (isPzOne) {
		// r = 1;
	} else {
		F::sqr(r, P.z);
	}
	if (isQzOne) {
		U1 = P.x;
		if (isPzOne) {
			H = Q.x;
		} else {
			F::mul(H, Q.x, r);
		}
		H -= U1;
		S1 = P.y;
	} else {
		F::sqr(S1, Q.z);
		F::mul(U1, P.x, S1);
		if (isPzOne) {
			H = Q.x;
		} else {
			F::mul(H, Q.x, r);
		}
		H -= U1;
		S1 *= Q.z;
		S1 *= P.y;
	}
	if (isPzOne) {
		r = Q.y;
	} else {
		r *= P.z;
		r *= Q.y;
	}
	r -= S1;
	if (H.isZero()) {
		if (r.isZero()) {
			ec::dblJacobi(R, P);
		} else {
			R.clear();
		}
		return;
	}
	if (isPzOne) {
		if (isQzOne) {
			R.z = H;
		} else {
			F::mul(R.z, H, Q.z);
		}
	} else {
		if (isQzOne) {
			F::mul(R.z, P.z, H);
		} else {
			F::mul(R.z, P.z, Q.z);
			R.z *= H;
		}
	}
	F::sqr(H3, H); // H^2
	F::sqr(R.y, r); // r^2
	U1 *= H3; // U1 H^2
	H3 *= H; // H^3
	R.y -= U1;
	R.y -= U1;
	F::sub(R.x, R.y, H3);
	U1 -= R.x;
	U1 *= r;
	H3 *= S1;
	F::sub(R.y, U1, H3);
}

/*
	accept P == Q
	https://github.com/apache/incubator-milagro-crypto-c/blob/fa0a45a3/src/ecp.c.in#L767-L976
	(x, y, z) is zero <=> x = 0, y = 1, z = 0
*/
template<class E>
void addCTProj(E& R, const E& P, const E& Q)
{
	typedef typename E::Fp F;
	assert(E::a_ == 0);
	F b3;
	F::add(b3, E::b_, E::b_);
	b3 += E::b_;
	F t0, t1, t2, t3, t4, x3, y3, z3;
	F::mul(t0, P.x, Q.x);
	F::mul(t1, P.y, Q.y);
	F::mul(t2, P.z, Q.z);
	F::add(t3, P.x, P.y);
	F::add(t4, Q.x, Q.y);
	F::mul(t3, t3, t4);
	F::add(t4, t0, t1);
	F::sub(t3, t3, t4);
	F::add(t4, P.y, P.z);
	F::add(x3, Q.y, Q.z);
	F::mul(t4, t4, x3);
	F::add(x3, t1, t2);
	F::sub(t4, t4, x3);
	F::add(x3, P.x, P.z);
	F::add(y3, Q.x, Q.z);
	F::mul(x3, x3, y3);
	F::add(y3, t0, t2);
	F::sub(y3, x3, y3);
	F::add(x3, t0, t0);
	F::add(t0, t0, x3);
	t2 *= b3;
	F::add(z3, t1, t2);
	F::sub(t1, t1, t2);
	y3 *= b3;
	F::mul(x3, y3, t4);
	F::mul(t2, t3, t1);
	F::sub(R.x, t2, x3);
	F::mul(y3, y3, t0);
	F::mul(t1, t1, z3);
	F::add(R.y, y3, t1);
	F::mul(t0, t0, t3);
	F::mul(z3, z3, t4);
	F::add(R.z, z3, t0);
}

template<class E>
void normalizeProj(E& P)
{
	typedef typename E::Fp F;
	if (P.z.isZero()) return;
	F::inv(P.z, P.z);
	P.x *= P.z;
	P.y *= P.z;
	P.z = 1;
}

// (Y^2 - bZ^2)Z = X(X^2 + aZ^2)
template<class E>
bool isValidProj(const E& P)
{
	typedef typename E::Fp F;
	F y2, x2, z2, t;
	F::sqr(x2, P.x);
	F::sqr(y2, P.y);
	F::sqr(z2, P.z);
	F::mul(t, E::a_, z2);
	t += x2;
	t *= P.x;
	z2 *= E::b_;
	y2 -= z2;
	y2 *= P.z;
	return y2 == t;
}

// (x/z, y/z)
template<class E>
bool isEqualProj(const E& P1, const E& P2)
{
	typedef typename E::Fp F;
	bool zero1 = P1.isZero();
	bool zero2 = P2.isZero();
	if (zero1) {
		return zero2;
	}
	if (zero2) return false;
	F t1, t2;
	F::mul(t1, P1.x, P2.z);
	F::mul(t2, P2.x, P1.z);
	if (t1 != t2) return false;
	F::mul(t1, P1.y, P2.z);
	F::mul(t2, P2.y, P1.z);
	return t1 == t2;
}

/*
	   |a=0|-3| generic
	mul|  8| 8| 9
	sqr|  4| 5| 5
	add| 11|12|12
*/
template<class E>
void dblProj(E& R, const E& P)
{
	typedef typename E::Fp F;
	if (P.isZero()) {
		R.clear();
		return;
	}
	const bool isPzOne = P.z.isOne();
	F w, t, h;
	switch (E::specialA_) {
	case Zero:
		F::sqr(w, P.x);
		F::add(t, w, w);
		w += t;
		break;
	case Minus3:
		F::sqr(w, P.x);
		if (isPzOne) {
			w -= P.z;
		} else {
			F::sqr(t, P.z);
			w -= t;
		}
		F::add(t, w, w);
		w += t;
		break;
	case GenericA:
	default:
		if (isPzOne) {
			w = E::a_;
		} else {
			F::sqr(w, P.z);
			w *= E::a_;
		}
		F::sqr(t, P.x);
		w += t;
		w += t;
		w += t; // w = a z^2 + 3x^2
		break;
	}
	if (isPzOne) {
		R.z = P.y;
	} else {
		F::mul(R.z, P.y, P.z); // s = yz
	}
	F::mul(t, R.z, P.x);
	t *= P.y; // xys
	t += t;
	t += t; // 4(xys) ; 4B
	F::sqr(h, w);
	h -= t;
	h -= t; // w^2 - 8B
	F::mul(R.x, h, R.z);
	t -= h; // h is free
	t *= w;
	F::sqr(w, P.y);
	R.x += R.x;
	R.z += R.z;
	F::sqr(h, R.z);
	w *= h;
	R.z *= h;
	F::sub(R.y, t, w);
	R.y -= w;
}

/*
	mul| 12
	sqr|  2
	add|  7
*/
template<class E>
void addProj(E& R, const E& P, const E& Q)
{
	typedef typename E::Fp F;
	if (P.isZero()) { R = Q; return; }
	if (Q.isZero()) { R = P; return; }
	bool isPzOne = P.z.isOne();
	bool isQzOne = Q.z.isOne();
	F r, PyQz, v, A, vv;
	if (isQzOne) {
		r = P.x;
		PyQz = P.y;
	} else {
		F::mul(r, P.x, Q.z);
		F::mul(PyQz, P.y, Q.z);
	}
	if (isPzOne) {
		A = Q.y;
		v = Q.x;
	} else {
		F::mul(A, Q.y, P.z);
		F::mul(v, Q.x, P.z);
	}
	v -= r;
	if (v.isZero()) {
		if (A == PyQz) {
			dblProj(R, P);
		} else {
			R.clear();
		}
		return;
	}
	F::sub(R.y, A, PyQz);
	F::sqr(A, R.y);
	F::sqr(vv, v);
	r *= vv;
	vv *= v;
	if (isQzOne) {
		R.z = P.z;
	} else {
		if (isPzOne) {
			R.z = Q.z;
		} else {
			F::mul(R.z, P.z, Q.z);
		}
	}
	// R.z = 1 if isPzOne && isQzOne
	if (isPzOne && isQzOne) {
		R.z = vv;
	} else {
		A *= R.z;
		R.z *= vv;
	}
	A -= vv;
	vv *= PyQz;
	A -= r;
	A -= r;
	F::mul(R.x, v, A);
	r -= A;
	R.y *= r;
	R.y -= vv;
}

// y^2 == (x^2 + a)x + b
template<class E>
bool isValidAffine(const E& P)
{
	typedef typename E::Fp F;
	assert(!P.z.isZero());
	F y2, t;
	F::sqr(y2, P.y);
	F::sqr(t, P.x);
	t += E::a_;
	t *= P.x;
	t += E::b_;
	return y2 == t;
}

// y^2 = x^3 + ax + b
template<class E>
static inline void dblAffine(E& R, const E& P)
{
	typedef typename E::Fp F;
	if (P.isZero()) {
		R.clear();
		return;
	}
	if (P.y.isZero()) {
		R.clear();
		return;
	}
	F t, s;
	F::sqr(t, P.x);
	F::add(s, t, t);
	t += s;
	t += E::a_;
	F::add(s, P.y, P.y);
	t /= s;
	F::sqr(s, t);
	s -= P.x;
	F x3;
	F::sub(x3, s, P.x);
	F::sub(s, P.x, x3);
	s *= t;
	F::sub(R.y, s, P.y);
	R.x = x3;
	R.z = 1;
}

template<class E>
void addAffine(E& R, const E& P, const E& Q)
{
	typedef typename E::Fp F;
	if (P.isZero()) { R = Q; return; }
	if (Q.isZero()) { R = P; return; }
	F t;
	F::sub(t, Q.x, P.x);
	if (t.isZero()) {
		if (P.y == Q.y) {
			dblAffine(R, P);
		} else {
			R.clear();
		}
		return;
	}
	F s;
	F::sub(s, Q.y, P.y);
	F::div(t, s, t);
	R.z = 1;
	F x3;
	F::sqr(x3, t);
	x3 -= P.x;
	x3 -= Q.x;
	F::sub(s, P.x, x3);
	s *= t;
	F::sub(R.y, s, P.y);
	R.x = x3;
}

template<class E>
void tryAndIncMapTo(E& P, const typename E::Fp& t)
{
	typedef typename E::Fp F;
	F x = t;
	for (;;) {
		F y;
		E::getWeierstrass(y, x);
		if (F::squareRoot(y, y)) {
			bool b;
			P.set(&b, x, y, false);
			assert(b);
			return;
		}
		*x.getFp0() += F::BaseFp::one();
	}
}

} // mcl::ec

/*
	elliptic curve
	y^2 = x^3 + ax + b (affine)
	y^2 = x^3 + az^4 + bz^6 (Jacobi) x = X/Z^2, y = Y/Z^3
*/
template<class _Fp>
class EcT : public fp::Serializable<EcT<_Fp> > {
public:
	typedef _Fp Fp;
	typedef _Fp BaseFp;
	Fp x, y, z;
	static int mode_;
	static Fp a_;
	static Fp b_;
	static int specialA_;
	static int ioMode_;
	/*
		order_ is the order of G2 which is the subgroup of EcT<Fp2>.
		check the order of the elements if verifyOrder_ is true
	*/
	static bool verifyOrder_;
	static mpz_class order_;
	static void (*mulArrayGLV)(EcT& z, const EcT& x, const fp::Unit *y, size_t yn, bool isNegative, bool constTime);
	static size_t (*mulVecNGLV)(EcT& z, const EcT *xVec, const mpz_class *yVec, size_t yn);
	static bool (*isValidOrderFast)(const EcT& x);
	/* default constructor is undefined value */
	EcT() {}
	EcT(const Fp& _x, const Fp& _y)
	{
		set(_x, _y);
	}
	bool isNormalized() const
	{
		return isZero() || z.isOne();
	}
private:
	bool isValidAffine() const
	{
		return ec::isValidAffine(*this);
	}
public:
	void normalize()
	{
		switch (mode_) {
		case ec::Jacobi:
			ec::normalizeJacobi(*this);
			break;
		case ec::Proj:
			ec::normalizeProj(*this);
			break;
		}
	}
	static void normalize(EcT& y, const EcT& x)
	{
		y = x;
		y.normalize();
	}
	static inline void init(const Fp& a, const Fp& b, int mode = ec::Jacobi)
	{
		a_ = a;
		b_ = b;
		if (a_.isZero()) {
			specialA_ = ec::Zero;
		} else if (a_ == -3) {
			specialA_ = ec::Minus3;
		} else {
			specialA_ = ec::GenericA;
		}
		ioMode_ = 0;
		verifyOrder_ = false;
		order_ = 0;
		mulArrayGLV = 0;
		mulVecNGLV = 0;
		isValidOrderFast = 0;
		mode_ = mode;
	}
	static inline int getMode() { return mode_; }
	/*
		verify the order of *this is equal to order if order != 0
		in constructor, set, setStr, operator<<().
	*/
	static void setOrder(const mpz_class& order)
	{
		if (order != 0) {
			verifyOrder_ = true;
			order_ = order;
		} else {
			verifyOrder_ = false;
			// don't clear order_ because it is used for isValidOrder()
		}
	}
	static void setVerifyOrderFunc(bool f(const EcT&))
	{
		isValidOrderFast = f;
	}
	static void setMulArrayGLV(void f(EcT& z, const EcT& x, const fp::Unit *y, size_t yn, bool isNegative, bool constTime), size_t g(EcT& z, const EcT *xVec, const mpz_class *yVec, size_t yn) = 0)
	{
		mulArrayGLV = f;
		mulVecNGLV = g;
	}
	static inline void init(bool *pb, const char *astr, const char *bstr, int mode = ec::Jacobi)
	{
		Fp a, b;
		a.setStr(pb, astr);
		if (!*pb) return;
		b.setStr(pb, bstr);
		if (!*pb) return;
		init(a, b, mode);
	}
	// verify the order
	bool isValidOrder() const
	{
		if (isValidOrderFast) {
			return isValidOrderFast(*this);
		}
		EcT Q;
		EcT::mulGeneric(Q, *this, order_);
		return Q.isZero();
	}
	bool isValid() const
	{
		switch (mode_) {
		case ec::Jacobi:
			if (!ec::isValidJacobi(*this)) return false;
			break;
		case ec::Proj:
			if (!ec::isValidProj(*this)) return false;
			break;
		case ec::Affine:
			if (z.isZero()) return true;
			if (!isValidAffine()) return false;
			break;
		}
		if (verifyOrder_) return isValidOrder();
		return true;
	}
	void set(bool *pb, const Fp& x, const Fp& y, bool verify = true)
	{
		this->x = x;
		this->y = y;
		z = 1;
		if (!verify || (isValidAffine() && (!verifyOrder_ || isValidOrder()))) {
			*pb = true;
			return;
		}
		*pb = false;
		clear();
	}
	void clear()
	{
		x.clear();
		y.clear();
		z.clear();
	}
	static inline void dbl(EcT& R, const EcT& P)
	{
		switch (mode_) {
		case ec::Jacobi:
			ec::dblJacobi(R, P);
			break;
		case ec::Proj:
			ec::dblProj(R, P);
			break;
		case ec::Affine:
			ec::dblAffine(R, P);
			break;
		}
	}
	static inline void add(EcT& R, const EcT& P, const EcT& Q)
	{
		switch (mode_) {
		case ec::Jacobi:
			ec::addJacobi(R, P, Q);
			break;
		case ec::Proj:
			ec::addProj(R, P, Q);
			break;
		case ec::Affine:
			ec::addAffine(R, P, Q);
			break;
		}
	}
	static inline void sub(EcT& R, const EcT& P, const EcT& Q)
	{
		EcT nQ;
		neg(nQ, Q);
		add(R, P, nQ);
	}
	static inline void neg(EcT& R, const EcT& P)
	{
		if (P.isZero()) {
			R.clear();
			return;
		}
		R.x = P.x;
		Fp::neg(R.y, P.y);
		R.z = P.z;
	}
	template<class tag, size_t maxBitSize, template<class _tag, size_t _maxBitSize>class FpT>
	static inline void mul(EcT& z, const EcT& x, const FpT<tag, maxBitSize>& y)
	{
		fp::Block b;
		y.getBlock(b);
		mulArray(z, x, b.p, b.n, false);
	}
	static inline void mul(EcT& z, const EcT& x, int64_t y)
	{
		const uint64_t u = fp::abs_(y);
#if MCL_SIZEOF_UNIT == 8
		mulArray(z, x, &u, 1, y < 0);
#else
		uint32_t ua[2] = { uint32_t(u), uint32_t(u >> 32) };
		size_t un = ua[1] ? 2 : 1;
		mulArray(z, x, ua, un, y < 0);
#endif
	}
	static inline void mul(EcT& z, const EcT& x, const mpz_class& y)
	{
		mulArray(z, x, gmp::getUnit(y), gmp::getUnitSize(y), y < 0);
	}
	template<class tag, size_t maxBitSize, template<class _tag, size_t _maxBitSize>class FpT>
	static inline void mulCT(EcT& z, const EcT& x, const FpT<tag, maxBitSize>& y)
	{
		fp::Block b;
		y.getBlock(b);
		mulArray(z, x, b.p, b.n, false, true);
	}
	static inline void mulCT(EcT& z, const EcT& x, const mpz_class& y)
	{
		mulArray(z, x, gmp::getUnit(y), gmp::getUnitSize(y), y < 0, true);
	}
	/*
		0 <= P for any P
		(Px, Py) <= (P'x, P'y) iff Px < P'x or Px == P'x and Py <= P'y
		@note compare function calls normalize()
	*/
	template<class F>
	static inline int compareFunc(const EcT& P_, const EcT& Q_, F comp)
	{
		const bool QisZero = Q_.isZero();
		if (P_.isZero()) {
			if (QisZero) return 0;
			return -1;
		}
		if (QisZero) return 1;
		EcT P(P_), Q(Q_);
		P.normalize();
		Q.normalize();
		int c = comp(P.x, Q.x);
		if (c > 0) return 1;
		if (c < 0) return -1;
		return comp(P.y, Q.y);
	}
	static inline int compare(const EcT& P, const EcT& Q)
	{
		return compareFunc(P, Q, Fp::compare);
	}
	static inline int compareRaw(const EcT& P, const EcT& Q)
	{
		return compareFunc(P, Q, Fp::compareRaw);
	}
	bool isZero() const
	{
		return z.isZero();
	}
	static inline bool isMSBserialize()
	{
		return !b_.isZero() && (Fp::BaseFp::getBitSize() & 7) != 0;
	}
	template<class OutputStream>
	void save(bool *pb, OutputStream& os, int ioMode) const
	{
		const char sep = *fp::getIoSeparator(ioMode);
		if (ioMode & IoEcProj) {
			cybozu::writeChar(pb, os, '4'); if (!*pb) return;
			if (sep) {
				cybozu::writeChar(pb, os, sep);
				if (!*pb) return;
			}
			x.save(pb, os, ioMode); if (!*pb) return;
			if (sep) {
				cybozu::writeChar(pb, os, sep);
				if (!*pb) return;
			}
			y.save(pb, os, ioMode); if (!*pb) return;
			if (sep) {
				cybozu::writeChar(pb, os, sep);
				if (!*pb) return;
			}
			z.save(pb, os, ioMode);
			return;
		}
		EcT P(*this);
		P.normalize();
		if (ioMode & IoEcAffineSerialize) {
			if (b_ == 0) { // assume Zero if x = y = 0
				*pb = false;
				return;
			}
			if (isZero()) {
				// all zero
				P.z.save(pb, os, IoSerialize);
				if (!*pb) return;
				P.z.save(pb, os, IoSerialize);
				return;
			}
			P.x.save(pb, os, IoSerialize);
			if (!*pb) return;
			P.y.save(pb, os, IoSerialize);
			return;
		}
		if (ioMode & (IoSerialize | IoSerializeHexStr)) {
			const size_t n = Fp::getByteSize();
			const size_t adj = isMSBserialize() ? 0 : 1;
			uint8_t buf[sizeof(Fp) + 1];
			if (Fp::BaseFp::isETHserialization()) {
				const uint8_t c_flag = 0x80;
				const uint8_t b_flag = 0x40;
				const uint8_t a_flag = 0x20;
				if (P.isZero()) {
					buf[0] = c_flag | b_flag;
					memset(buf + 1, 0, n - 1);
				} else {
					cybozu::MemoryOutputStream mos(buf, n);
					P.x.save(pb, mos, IoSerialize); if (!*pb) return;
					uint8_t cba = c_flag;
					if (ec::local::get_a_flag(P.y)) cba |= a_flag;
					buf[0] |= cba;
				}
			} else {
				/*
					if (isMSBserialize()) {
					  // n bytes
					  x | (y.isOdd ? 0x80 : 0)
					} else {
					  // n + 1 bytes
					  (y.isOdd ? 3 : 2), x
					}
				*/
				if (isZero()) {
					memset(buf, 0, n + adj);
				} else {
					cybozu::MemoryOutputStream mos(buf + adj, n);
					P.x.save(pb, mos, IoSerialize); if (!*pb) return;
					if (adj) {
						buf[0] = P.y.isOdd() ? 3 : 2;
					} else {
						if (P.y.isOdd()) {
							buf[n - 1] |= 0x80;
						}
					}
				}
			}
			if (ioMode & IoSerializeHexStr) {
				mcl::fp::writeHexStr(pb, os, buf, n + adj);
			} else {
				cybozu::write(pb, os, buf, n + adj);
			}
			return;
		}
		if (isZero()) {
			cybozu::writeChar(pb, os, '0');
			return;
		}
		if (ioMode & IoEcCompY) {
			cybozu::writeChar(pb, os, P.y.isOdd() ? '3' : '2');
			if (!*pb) return;
			if (sep) {
				cybozu::writeChar(pb, os, sep);
				if (!*pb) return;
			}
			P.x.save(pb, os, ioMode);
		} else {
			cybozu::writeChar(pb, os, '1'); if (!*pb) return;
			if (sep) {
				cybozu::writeChar(pb, os, sep);
				if (!*pb) return;
			}
			P.x.save(pb, os, ioMode); if (!*pb) return;
			if (sep) {
				cybozu::writeChar(pb, os, sep);
				if (!*pb) return;
			}
			P.y.save(pb, os, ioMode);
		}
	}
	template<class InputStream>
	void load(bool *pb, InputStream& is, int ioMode)
	{
		z = 1;
		if (ioMode & IoEcAffineSerialize) {
			if (b_ == 0) { // assume Zero if x = y = 0
				*pb = false;
				return;
			}
			x.load(pb, is, IoSerialize);
			if (!*pb) return;
			y.load(pb, is, IoSerialize);
			if (!*pb) return;
			if (x.isZero() && y.isZero()) {
				z.clear();
				return;
			}
			goto verifyValidAffine;
		}
		if (ioMode & (IoSerialize | IoSerializeHexStr)) {
			const size_t n = Fp::getByteSize();
			const size_t adj = isMSBserialize() ? 0 : 1;
			const size_t n1 = n + adj;
			uint8_t buf[sizeof(Fp) + 1];
			size_t readSize;
			if (ioMode & IoSerializeHexStr) {
				readSize = mcl::fp::readHexStr(buf, n1, is);
			} else {
				readSize = cybozu::readSome(buf, n1, is);
			}
			if (readSize != n1) {
				*pb = false;
				return;
			}
			if (Fp::BaseFp::isETHserialization()) {
				const uint8_t c_flag = 0x80;
				const uint8_t b_flag = 0x40;
				const uint8_t a_flag = 0x20;
				*pb = false;
				if ((buf[0] & c_flag) == 0) { // assume compressed
					return;
				}
				if (buf[0] & b_flag) { // infinity
					if (buf[0] != (c_flag | b_flag)) return;
					for (size_t i = 1; i < n - 1; i++) {
						if (buf[i]) return;
					}
					clear();
					*pb = true;
					return;
				}
				bool a = (buf[0] & a_flag) != 0;
				buf[0] &= ~(c_flag | b_flag | a_flag);
				mcl::fp::local::byteSwap(buf, n);
				x.setArray(pb, buf, n);
				if (!*pb) return;
				getWeierstrass(y, x);
				if (!Fp::squareRoot(y, y)) {
					*pb = false;
					return;
				}
				if (ec::local::get_a_flag(y) ^ a) {
					Fp::neg(y, y);
				}
				goto verifyOrder;
			}
			if (fp::isZeroArray(buf, n1)) {
				clear();
				*pb = true;
				return;
			}
			bool isYodd;
			if (adj) {
				char c = buf[0];
				if (c != 2 && c != 3) {
					*pb = false;
					return;
				}
				isYodd = c == 3;
			} else {
				isYodd = (buf[n - 1] >> 7) != 0;
				buf[n - 1] &= 0x7f;
			}
			x.setArray(pb, buf + adj, n);
			if (!*pb) return;
			*pb = getYfromX(y, x, isYodd);
			if (!*pb) return;
		} else {
			char c = 0;
			if (!fp::local::skipSpace(&c, is)) {
				*pb = false;
				return;
			}
			if (c == '0') {
				clear();
				*pb = true;
				return;
			}
			x.load(pb, is, ioMode); if (!*pb) return;
			if (c == '1') {
				y.load(pb, is, ioMode); if (!*pb) return;
				goto verifyValidAffine;
			} else if (c == '2' || c == '3') {
				bool isYodd = c == '3';
				*pb = getYfromX(y, x, isYodd);
				if (!*pb) return;
			} else if (c == '4') {
				y.load(pb, is, ioMode); if (!*pb) return;
				z.load(pb, is, ioMode); if (!*pb) return;
				if (mode_ == ec::Affine) {
					if (!z.isZero() && !z.isOne()) {
						*pb = false;
						return;
					}
				}
				*pb = isValid();
				return;
			} else {
				*pb = false;
				return;
			}
		}
	verifyOrder:
		if (verifyOrder_ && !isValidOrder()) {
			*pb = false;
		} else {
			*pb = true;
		}
		return;
	verifyValidAffine:
		if (!isValidAffine()) {
			*pb = false;
			return;
		}
		goto verifyOrder;
	}
	// deplicated
	static void setCompressedExpression(bool compressedExpression = true)
	{
		if (compressedExpression) {
			ioMode_ |= IoEcCompY;
		} else {
			ioMode_ &= ~IoEcCompY;
		}
	}
	/*
		set IoMode for operator<<(), or operator>>()
	*/
	static void setIoMode(int ioMode)
	{
		assert(!(ioMode & 0xff));
		ioMode_ = ioMode;
	}
	static inline int getIoMode() { return Fp::BaseFp::getIoMode() | ioMode_; }
	static inline void getWeierstrass(Fp& yy, const Fp& x)
	{
		Fp t;
		Fp::sqr(t, x);
		t += a_;
		t *= x;
		Fp::add(yy, t, b_);
	}
	static inline bool getYfromX(Fp& y, const Fp& x, bool isYodd)
	{
		getWeierstrass(y, x);
		if (!Fp::squareRoot(y, y)) {
			return false;
		}
		if (y.isOdd() ^ isYodd) {
			Fp::neg(y, y);
		}
		return true;
	}
	inline friend EcT operator+(const EcT& x, const EcT& y) { EcT z; add(z, x, y); return z; }
	inline friend EcT operator-(const EcT& x, const EcT& y) { EcT z; sub(z, x, y); return z; }
	template<class INT>
	inline friend EcT operator*(const EcT& x, const INT& y) { EcT z; mul(z, x, y); return z; }
	EcT& operator+=(const EcT& x) { add(*this, *this, x); return *this; }
	EcT& operator-=(const EcT& x) { sub(*this, *this, x); return *this; }
	template<class INT>
	EcT& operator*=(const INT& x) { mul(*this, *this, x); return *this; }
	EcT operator-() const { EcT x; neg(x, *this); return x; }
	bool operator==(const EcT& rhs) const
	{
		switch (mode_) {
		case ec::Jacobi:
			return ec::isEqualJacobi(*this, rhs);
		case ec::Proj:
			return ec::isEqualProj(*this, rhs);
		case ec::Affine:
		default:
			return x == rhs.x && y == rhs.y && z == rhs.z;
		}
	}
	bool operator!=(const EcT& rhs) const { return !operator==(rhs); }
	bool operator<(const EcT& rhs) const
	{
		return compare(*this, rhs) < 0;
	}
	bool operator>=(const EcT& rhs) const { return !operator<(rhs); }
	bool operator>(const EcT& rhs) const { return rhs < *this; }
	bool operator<=(const EcT& rhs) const { return !operator>(rhs); }
	static inline void mulArray(EcT& z, const EcT& x, const fp::Unit *y, size_t yn, bool isNegative, bool constTime = false, bool useGLV = true)
	{
		if (!constTime) {
			if (yn == 0) {
				z.clear();
				return;
			}
			yn = fp::getNonZeroArraySize(y, yn);
			if (yn <= 1 && mulSmallInt(z, x, *y, isNegative)) return;
		}
		if (useGLV && mulArrayGLV && (yn * sizeof(fp::Unit) > 8)) {
			mulArrayGLV(z, x, y, yn, isNegative, constTime);
			return;
		}
		mulArrayBase(z, x, y, yn, isNegative, constTime);
	}
	static inline bool mulSmallInt(EcT& z, const EcT& x, fp::Unit y, bool isNegative)
	{
		switch (y) {
		case 0: z.clear(); return true;
		case 1: z = x; break;
		case 2: dbl(z, x); break;
		case 3: {
			EcT t;
			dbl(t, x);
			add(z, t, x);
			break;
		}
		case 4: {
			dbl(z, x);
			dbl(z, z);
			break;
		}
		case 5: {
			EcT t;
			dbl(t, x);
			dbl(t, t);
			add(z, t, x);
			break;
		}
		case 6: {
			EcT t;
			dbl(t, x);
			add(z, t, x);
			dbl(z, z);
			break;
		}
		case 7: {
			EcT t;
			dbl(t, x);
			dbl(t, t);
			dbl(t, t);
			sub(z, t, x);
			break;
		}
		case 8: {
			dbl(z, x);
			dbl(z, z);
			dbl(z, z);
			break;
		}
		case 9: {
			EcT t;
			dbl(t, x);
			dbl(t, t);
			dbl(t, t);
			add(z, t, x);
			break;
		}
		case 10: {
			EcT t;
			dbl(t, x);
			dbl(t, t);
			add(z, t, x);
			dbl(z, z);
			break;
		}
		case 11: {
			EcT t1, t2;
			dbl(t1, x); // 2x
			dbl(t2, t1);
			dbl(t2, t2); // 8x
			add(t2, t2, t1);
			add(z, t2, x);
			break;
		}
		case 12: {
			EcT t1, t2;
			dbl(t1, x);
			dbl(t1, t1); // 4x
			dbl(t2, t1); // 8x
			add(z, t1, t2);
			break;
		}
		case 13: {
			EcT t1, t2;
			dbl(t1, x);
			dbl(t1, t1); // 4x
			dbl(t2, t1); // 8x
			add(t1, t1, t2); // 12x
			add(z, t1, x);
			break;
		}
		case 14: {
			EcT t;
			// (8 - 1) * 2
			dbl(t, x);
			dbl(t, t);
			dbl(t, t);
			sub(t, t, x);
			dbl(z, t);
			break;
		}
		case 15: {
			EcT t;
			dbl(t, x);
			dbl(t, t);
			dbl(t, t);
			dbl(t, t);
			sub(z, t, x);
			break;
		}
		case 16: {
			dbl(z, x);
			dbl(z, z);
			dbl(z, z);
			dbl(z, z);
			break;
		}
		default:
			return false;
		}
		if (isNegative) {
			neg(z, z);
		}
		return true;
	}
	static inline void mulArrayBase(EcT& z, const EcT& x, const fp::Unit *y, size_t yn, bool isNegative, bool constTime)
	{
		(void)constTime;
		mpz_class v;
		bool b;
		gmp::setArray(&b, v, y, yn);
		assert(b); (void)b;
		if (isNegative) v = -v;
		const int maxW = 5;
		const int maxTblSize = 1 << (maxW - 2);
		/*
			L = log2(y), w = (L <= 32) ? 3 : (L <= 128) ? 4 : 5;
		*/
		const int w = (yn == 1 && *y <= (1ull << 32)) ? 3 : (yn * sizeof(fp::Unit) > 16) ? 5 : 4;
		const size_t tblSize = size_t(1) << (w - 2);
		typedef mcl::FixedArray<int8_t, sizeof(EcT::Fp) * 8 + 1> NafArray;
		NafArray naf;
		EcT tbl[maxTblSize];
		gmp::getNAFwidth(&b, naf, v, w);
		assert(b); (void)b;
		EcT P2;
		dbl(P2, x);
		tbl[0] = x;
		for (size_t i = 1; i < tblSize; i++) {
			add(tbl[i], tbl[i - 1], P2);
		}
		z.clear();
		for (size_t i = 0; i < naf.size(); i++) {
			EcT::dbl(z, z);
			local::addTbl(z, tbl, naf, naf.size() - 1 - i);
		}
	}
	/*
		generic mul
		GLV can't be applied in Fp12 - GT
	*/
	static inline void mulGeneric(EcT& z, const EcT& x, const mpz_class& y, bool constTime = false)
	{
		mulArray(z, x, gmp::getUnit(y), gmp::getUnitSize(y), y < 0, constTime, false);
	}
	/*
		z = sum_{i=0}^{n-1} xVec[i] * yVec[i]
		return min(N, n)
		@note &z != xVec[i]
	*/
private:
	template<class tag, size_t maxBitSize, template<class _tag, size_t _maxBitSize>class FpT>
	static inline size_t mulVecN(EcT& z, const EcT *xVec, const FpT<tag, maxBitSize> *yVec, size_t n)
	{
		const size_t N = mcl::fp::maxMulVecN;
		if (n > N) n = N;
		const int w = 5;
		const size_t tblSize = 1 << (w - 2);
		typedef mcl::FixedArray<int8_t, sizeof(EcT::Fp) * 8 + 1> NafArray;
		NafArray naf[N];
		EcT tbl[N][tblSize];
		size_t maxBit = 0;
		mpz_class y;
		for (size_t i = 0; i < n; i++) {
			bool b;
			yVec[i].getMpz(&b, y);
			assert(b); (void)b;
			gmp::getNAFwidth(&b, naf[i], y, w);
			assert(b); (void)b;
			if (naf[i].size() > maxBit) maxBit = naf[i].size();
			EcT P2;
			EcT::dbl(P2, xVec[i]);
			tbl[i][0] = xVec[i];
			for (size_t j = 1; j < tblSize; j++) {
				EcT::add(tbl[i][j], tbl[i][j - 1], P2);
			}
		}
		z.clear();
		for (size_t i = 0; i < maxBit; i++) {
			EcT::dbl(z, z);
			for (size_t j = 0; j < n; j++) {
				local::addTbl(z, tbl[j], naf[j], maxBit - 1 - i);
			}
		}
		return n;
	}

public:
	template<class tag, size_t maxBitSize, template<class _tag, size_t _maxBitSize>class FpT>
	static inline void mulVec(EcT& z, const EcT *xVec, const FpT<tag, maxBitSize> *yVec, size_t n)
	{
		/*
			mulVecNGLV is a little slow for large n
		*/
#if 1
		if (mulVecNGLV && n < mcl::fp::maxMulVecNGLV) {
			mpz_class myVec[mcl::fp::maxMulVecNGLV];
			for (size_t i = 0; i < n; i++) {
				bool b;
				yVec[i].getMpz(&b, myVec[i]);
				assert(b); (void)b;
			}
			size_t done = mulVecNGLV(z, xVec, myVec, n);
			assert(done == n); (void)done;
			return;
		}
#else
		if (mulVecNGLV) {
			EcT r;
			r.clear();
			mpz_class myVec[mcl::fp::maxMulVecNGLV];
			while (n > 0) {
				size_t nn = mcl::fp::min_(mcl::fp::maxMulVecNGLV, n);
				for (size_t i = 0; i < nn; i++) {
					bool b;
					yVec[i].getMpz(&b, myVec[i]);
					assert(b); (void)b;
				}
				EcT t;
				size_t done = mulVecNGLV(t, xVec, myVec, nn);
				assert(nn == done);
				r += t;
				xVec += done;
				yVec += done;
				n -= done;
			}
			z = r;
			return;
		}
#endif
		EcT r;
		r.clear();
		while (n > 0) {
			EcT t;
			size_t done = mulVecN(t, xVec, yVec, n);
			r += t;
			xVec += done;
			yVec += done;
			n -= done;
		}
		z = r;
	}
	// multi thread version of mulVec
	// the num of thread is automatically detected if cpuN = 0
	template<class tag, size_t maxBitSize, template<class _tag, size_t _maxBitSize>class FpT>
	static inline void mulVecMT(EcT& z, const EcT *xVec, const FpT<tag, maxBitSize> *yVec, size_t n, size_t cpuN = 0)
	{
#ifdef MCL_USE_OMP
	const size_t minN = mcl::fp::maxMulVecN;
	if (cpuN == 0) {
		cpuN = omp_get_num_procs();
		if (n < minN * cpuN) {
			cpuN = (n + minN - 1) / minN;
		}
	}
	if (cpuN <= 1 || n <= cpuN) {
		mulVec(z, xVec, yVec, n);
		return;
	}
	EcT *zs = (EcT*)CYBOZU_ALLOCA(sizeof(EcT) * cpuN);
	size_t q = n / cpuN;
	size_t r = n % cpuN;
	#pragma omp parallel for
	for (size_t i = 0; i < cpuN; i++) {
		size_t adj = q * i + fp::min_(i, r);
		mulVec(zs[i], xVec + adj, yVec + adj, q + (i < r));
	}
	z.clear();
//	#pragma omp declare reduction(red:EcT:omp_out *= omp_in) initializer(omp_priv = omp_orig)
//	#pragma omp parallel for reduction(red:z)
	for (size_t i = 0; i < cpuN; i++) {
		z += zs[i];
	}
#else
		(void)cpuN;
		mulVec(z, xVec, yVec, n);
#endif
	}
#ifndef CYBOZU_DONT_USE_EXCEPTION
	static inline void init(const std::string& astr, const std::string& bstr, int mode = ec::Jacobi)
	{
		bool b;
		init(&b, astr.c_str(), bstr.c_str(), mode);
		if (!b) throw cybozu::Exception(""mcl:EcT:init"");
	}
	void set(const Fp& _x, const Fp& _y, bool verify = true)
	{
		bool b;
		set(&b, _x, _y, verify);
		if (!b) throw cybozu::Exception(""ec:EcT:set"") << _x << _y;
	}
	template<class OutputStream>
	void save(OutputStream& os, int ioMode = IoSerialize) const
	{
		bool b;
		save(&b, os, ioMode);
		if (!b) throw cybozu::Exception(""EcT:save"");
	}
	template<class InputStream>
	void load(InputStream& is, int ioMode = IoSerialize)
	{
		bool b;
		load(&b, is, ioMode);
		if (!b) throw cybozu::Exception(""EcT:load"");
	}
#endif
#ifndef CYBOZU_DONT_USE_STRING
	// backward compatilibity
	static inline void setParam(const std::string& astr, const std::string& bstr, int mode = ec::Jacobi)
	{
		init(astr, bstr, mode);
	}
	friend inline std::istream& operator>>(std::istream& is, EcT& self)
	{
		self.load(is, fp::detectIoMode(getIoMode(), is));
		return is;
	}
	friend inline std::ostream& operator<<(std::ostream& os, const EcT& self)
	{
		self.save(os, fp::detectIoMode(getIoMode(), os));
		return os;
	}
#endif
};

template<class Fp> Fp EcT<Fp>::a_;
template<class Fp> Fp EcT<Fp>::b_;
template<class Fp> int EcT<Fp>::specialA_;
template<class Fp> int EcT<Fp>::ioMode_;
template<class Fp> bool EcT<Fp>::verifyOrder_;
template<class Fp> mpz_class EcT<Fp>::order_;
template<class Fp> void (*EcT<Fp>::mulArrayGLV)(EcT& z, const EcT& x, const fp::Unit *y, size_t yn, bool isNegative, bool constTime);
template<class Fp> size_t (*EcT<Fp>::mulVecNGLV)(EcT& z, const EcT *xVec, const mpz_class *yVec, size_t yn);
template<class Fp> bool (*EcT<Fp>::isValidOrderFast)(const EcT& x);
template<class Fp> int EcT<Fp>::mode_;

// r = the order of Ec
template<class Ec, class _Fr>
struct GLV1T {
	typedef GLV1T<Ec, _Fr> GLV1;
	typedef typename Ec::Fp Fp;
	typedef _Fr Fr;
	static Fp rw; // rw = 1 / w = (-1 - sqrt(-3)) / 2
	static size_t rBitSize;
	static mpz_class v0, v1;
	static mpz_class B[2][2];
public:
#ifndef CYBOZU_DONT_USE_STRING
	static void dump(const mpz_class& x)
	{
		printf(""\\""%s\\"",\\n"", mcl::gmp::getStr(x, 16).c_str());
	}
	static void dump()
	{
		printf(""\\""%s\\"",\\n"", rw.getStr(16).c_str());
		printf(""%d,\\n"", (int)rBitSize);
		dump(v0);
		dump(v1);
		dump(B[0][0]); dump(B[0][1]); dump(B[1][0]); dump(B[1][1]);
	}
#endif
	/*
		L (x, y) = (rw x, y)
	*/
	static void mulLambda(Ec& Q, const Ec& P)
	{
		Fp::mul(Q.x, P.x, rw);
		Q.y = P.y;
		Q.z = P.z;
	}
	/*
		x = u[0] + u[1] * lambda mod r
	*/
	static void split(mpz_class u[2], const mpz_class& x)
	{
		mpz_class& a = u[0];
		mpz_class& b = u[1];
		mpz_class t;
		t = (x * v0) >> rBitSize;
		b = (x * v1) >> rBitSize;
		a = x - (t * B[0][0] + b * B[1][0]);
		b = - (t * B[0][1] + b * B[1][1]);
	}
	static void mul(Ec& Q, const Ec& P, const mpz_class& x, bool constTime = false)
	{
		if (constTime) {
			ec::local::mul1CT<GLV1, Ec, _Fr, 2, 4>(Q, P, x);
		} else {
			ec::local::mulVecNGLVT<GLV1, Ec, _Fr, 2, 5, 1>(Q, &P, &x, 1);
		}
	}
	static inline size_t mulVecNGLV(Ec& z, const Ec *xVec, const mpz_class *yVec, size_t n)
	{
		return ec::local::mulVecNGLVT<GLV1, Ec, _Fr, 2, 5, mcl::fp::maxMulVecNGLV>(z, xVec, yVec, n);
	}
	static void mulArrayGLV(Ec& z, const Ec& x, const mcl::fp::Unit *y, size_t yn, bool isNegative, bool constTime)
	{
		mpz_class s;
		bool b;
		mcl::gmp::setArray(&b, s, y, yn);
		assert(b);
		if (isNegative) s = -s;
		mul(z, x, s, constTime);
	}
	/*
		initForBN() is defined in bn.hpp
	*/
	static void initForSecp256k1()
	{
		bool b = Fp::squareRoot(rw, -3);
		assert(b);
		(void)b;
		rw = -(rw + 1) / 2;
		rBitSize = Fr::getOp().bitSize;
		rBitSize = (rBitSize + fp::UnitBitSize - 1) & ~(fp::UnitBitSize - 1);
		gmp::setStr(&b, B[0][0], ""0x3086d221a7d46bcde86c90e49284eb15"");
		assert(b); (void)b;
		gmp::setStr(&b, B[0][1], ""-0xe4437ed6010e88286f547fa90abfe4c3"");
		assert(b); (void)b;
		gmp::setStr(&b, B[1][0], ""0x114ca50f7a8e2f3f657c1108d9d44cfd8"");
		assert(b); (void)b;
		B[1][1] = B[0][0];
		const mpz_class& r = Fr::getOp().mp;
		v0 = ((B[1][1]) << rBitSize) / r;
		v1 = ((-B[0][1]) << rBitSize) / r;
	}
};

// rw = 1 / w = (-1 - sqrt(-3)) / 2
template<class Ec, class Fr> typename Ec::Fp GLV1T<Ec, Fr>::rw;
template<class Ec, class Fr> size_t GLV1T<Ec, Fr>::rBitSize;
template<class Ec, class Fr> mpz_class GLV1T<Ec, Fr>::v0;
template<class Ec, class Fr> mpz_class GLV1T<Ec, Fr>::v1;
template<class Ec, class Fr> mpz_class GLV1T<Ec, Fr>::B[2][2];

/*
	Ec : elliptic curve
	Zn : cyclic group of the order |Ec|
	set P the generator of Ec if P != 0
*/
template<class Ec, class Zn>
void initCurve(bool *pb, int curveType, Ec *P = 0, mcl::fp::Mode mode = fp::FP_AUTO, mcl::ec::Mode ecMode = ec::Jacobi)
{
	typedef typename Ec::Fp Fp;
	*pb = false;
	const EcParam *ecParam = getEcParam(curveType);
	if (ecParam == 0) return;

	Zn::init(pb, ecParam->n, mode);
	if (!*pb) return;
	Fp::init(pb, ecParam->p, mode);
	if (!*pb) return;
	Ec::init(pb, ecParam->a, ecParam->b, ecMode);
	if (!*pb) return;
	if (P) {
		Fp x, y;
		x.setStr(pb, ecParam->gx);
		if (!*pb) return;
		y.setStr(pb, ecParam->gy);
		if (!*pb) return;
		P->set(pb, x, y);
		if (!*pb) return;
	}
	if (curveType == MCL_SECP256K1) {
		GLV1T<Ec, Zn>::initForSecp256k1();
		Ec::setMulArrayGLV(GLV1T<Ec, Zn>::mulArrayGLV, GLV1T<Ec, Zn>::mulVecNGLV);
	} else {
		Ec::setMulArrayGLV(0);
	}
}

#ifndef CYBOZU_DONT_USE_EXCEPTION
template<class Ec, class Zn>
void initCurve(int curveType, Ec *P = 0, mcl::fp::Mode mode = fp::FP_AUTO, mcl::ec::Mode ecMode = ec::Jacobi)
{
	bool b;
	initCurve<Ec, Zn>(&b, curveType, P, mode, ecMode);
	if (!b) throw cybozu::Exception(""mcl:initCurve"") << curveType << mode << ecMode;
}
#endif

} // mcl

#ifndef CYBOZU_DONT_USE_EXCEPTION
#ifdef CYBOZU_USE_BOOST
namespace mcl {
template<class Fp>
size_t hash_value(const mcl::EcT<Fp>& P_)
{
	if (P_.isZero()) return 0;
	mcl::EcT<Fp> P(P_); P.normalize();
	return mcl::hash_value(P.y, mcl::hash_value(P.x));
}

}
#else
namespace std { CYBOZU_NAMESPACE_TR1_BEGIN

template<class Fp>
struct hash<mcl::EcT<Fp> > {
	size_t operator()(const mcl::EcT<Fp>& P_) const
	{
		if (P_.isZero()) return 0;
		mcl::EcT<Fp> P(P_); P.normalize();
		return hash<Fp>()(P.y, hash<Fp>()(P.x));
	}
};

CYBOZU_NAMESPACE_TR1_END } // std
#endif
#endif

#ifdef _MSC_VER
	#pragma warning(pop)
#endif
",16341,True,3178.5609797298243,median
"/******************************************************************************
 * Spine Runtimes License Agreement
 * Last updated January 1, 2020. Replaces all prior versions.
 *
 * Copyright (c) 2013-2020, Esoteric Software LLC
 *
 * Integration of the Spine Runtimes into software or otherwise creating
 * derivative works of the Spine Runtimes is permitted under the terms and
 * conditions of Section 2 of the Spine Editor License Agreement:
 * http://esotericsoftware.com/spine-editor-license
 *
 * Otherwise, it is permitted to integrate the Spine Runtimes into software
 * or otherwise create derivative works of the Spine Runtimes (collectively,
 * ""Products""), provided that each user of the Products must obtain their own
 * Spine Editor license and redistribution of the Products in any form must
 * include this license and copyright notice.
 *
 * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC ""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 ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
 * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) 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
 * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/

#ifdef SPINE_UE4
#include ""SpinePluginPrivatePCH.h""
#endif

#include <spine/SkeletonJson.h>

#include <spine/Atlas.h>
#include <spine/AtlasAttachmentLoader.h>
#include <spine/CurveTimeline.h>
#include <spine/Json.h>
#include <spine/LinkedMesh.h>
#include <spine/SkeletonData.h>
#include <spine/VertexAttachment.h>

#include <spine/AttachmentTimeline.h>
#include <spine/AttachmentType.h>
#include <spine/BoneData.h>
#include <spine/BoundingBoxAttachment.h>
#include <spine/ClippingAttachment.h>
#include <spine/ColorTimeline.h>
#include <spine/ContainerUtil.h>
#include <spine/DeformTimeline.h>
#include <spine/DrawOrderTimeline.h>
#include <spine/Event.h>
#include <spine/EventData.h>
#include <spine/EventTimeline.h>
#include <spine/IkConstraintData.h>
#include <spine/IkConstraintTimeline.h>
#include <spine/MeshAttachment.h>
#include <spine/PathAttachment.h>
#include <spine/PathConstraintData.h>
#include <spine/PathConstraintMixTimeline.h>
#include <spine/PathConstraintPositionTimeline.h>
#include <spine/PathConstraintSpacingTimeline.h>
#include <spine/PointAttachment.h>
#include <spine/RegionAttachment.h>
#include <spine/RotateTimeline.h>
#include <spine/ScaleTimeline.h>
#include <spine/ShearTimeline.h>
#include <spine/Skin.h>
#include <spine/SlotData.h>
#include <spine/TransformConstraintData.h>
#include <spine/TransformConstraintTimeline.h>
#include <spine/TranslateTimeline.h>
#include <spine/Vertices.h>

#if defined(WIN32) || defined(_WIN32) || defined(__WIN32) && !defined(__CYGWIN__)
#define strdup _strdup
#endif

using namespace spine;

static float toColor(const char *value, size_t index) {
	char digits[3];
	char *error;
	int color;

	if (index >= strlen(value) / 2) return -1;

	value += index * 2;

	digits[0] = *value;
	digits[1] = *(value + 1);
	digits[2] = '\\0';
	color = (int) strtoul(digits, &error, 16);
	if (*error != 0) return -1;

	return color / (float) 255;
}

static void toColor(Color &color, const char *value, bool hasAlpha) {
	color.r = toColor(value, 0);
	color.g = toColor(value, 1);
	color.b = toColor(value, 2);
	if (hasAlpha) color.a = toColor(value, 3);
}

SkeletonJson::SkeletonJson(Atlas *atlas) : _attachmentLoader(new (__FILE__, __LINE__) AtlasAttachmentLoader(atlas)),
										   _scale(1), _ownsLoader(true) {}

SkeletonJson::SkeletonJson(AttachmentLoader *attachmentLoader, bool ownsLoader) : _attachmentLoader(attachmentLoader),
																				  _scale(1),
																				  _ownsLoader(ownsLoader) {
	assert(_attachmentLoader != NULL);
}

SkeletonJson::~SkeletonJson() {
	ContainerUtil::cleanUpVectorOfPointers(_linkedMeshes);

	if (_ownsLoader) delete _attachmentLoader;
}

SkeletonData *SkeletonJson::readSkeletonDataFile(const String &path) {
	int length;
	SkeletonData *skeletonData;
	const char *json = SpineExtension::readFile(path, &length);
	if (length == 0 || !json) {
		setError(NULL, ""Unable to read skeleton file: "", path);
		return NULL;
	}

	skeletonData = readSkeletonData(json);

	SpineExtension::free(json, __FILE__, __LINE__);

	return skeletonData;
}

SkeletonData *SkeletonJson::readSkeletonData(const char *json) {
	int i, ii;
	SkeletonData *skeletonData;
	Json *root, *skeleton, *bones, *boneMap, *ik, *transform, *path, *slots, *skins, *animations, *events;

	_error = """";
	_linkedMeshes.clear();

	root = new (__FILE__, __LINE__) Json(json);

	if (!root) {
		setError(NULL, ""Invalid skeleton JSON: "", Json::getError());
		return NULL;
	}

	skeletonData = new (__FILE__, __LINE__) SkeletonData();

	skeleton = Json::getItem(root, ""skeleton"");
	if (skeleton) {
		skeletonData->_hash = Json::getString(skeleton, ""hash"", 0);
		skeletonData->_version = Json::getString(skeleton, ""spine"", 0);
		skeletonData->_x = Json::getFloat(skeleton, ""x"", 0);
		skeletonData->_y = Json::getFloat(skeleton, ""y"", 0);
		skeletonData->_width = Json::getFloat(skeleton, ""width"", 0);
		skeletonData->_height = Json::getFloat(skeleton, ""height"", 0);
		skeletonData->_fps = Json::getFloat(skeleton, ""fps"", 30);
		skeletonData->_audioPath = Json::getString(skeleton, ""audio"", 0);
		skeletonData->_imagesPath = Json::getString(skeleton, ""images"", 0);
	}

	/* Bones. */
	bones = Json::getItem(root, ""bones"");
	skeletonData->_bones.setSize(bones->_size, 0);
	int bonesCount = 0;
	for (boneMap = bones->_child, i = 0; boneMap; boneMap = boneMap->_next, ++i) {
		BoneData *data;
		const char *transformMode;

		BoneData *parent = 0;
		const char *parentName = Json::getString(boneMap, ""parent"", 0);
		if (parentName) {
			parent = skeletonData->findBone(parentName);
			if (!parent) {
				delete skeletonData;
				setError(root, ""Parent bone not found: "", parentName);
				return NULL;
			}
		}

		data = new (__FILE__, __LINE__) BoneData(bonesCount, Json::getString(boneMap, ""name"", 0), parent);

		data->_length = Json::getFloat(boneMap, ""length"", 0) * _scale;
		data->_x = Json::getFloat(boneMap, ""x"", 0) * _scale;
		data->_y = Json::getFloat(boneMap, ""y"", 0) * _scale;
		data->_rotation = Json::getFloat(boneMap, ""rotation"", 0);
		data->_scaleX = Json::getFloat(boneMap, ""scaleX"", 1);
		data->_scaleY = Json::getFloat(boneMap, ""scaleY"", 1);
		data->_shearX = Json::getFloat(boneMap, ""shearX"", 0);
		data->_shearY = Json::getFloat(boneMap, ""shearY"", 0);
		transformMode = Json::getString(boneMap, ""transform"", ""normal"");
		data->_transformMode = TransformMode_Normal;
		if (strcmp(transformMode, ""normal"") == 0) data->_transformMode = TransformMode_Normal;
		else if (strcmp(transformMode, ""onlyTranslation"") == 0)
			data->_transformMode = TransformMode_OnlyTranslation;
		else if (strcmp(transformMode, ""noRotationOrReflection"") == 0)
			data->_transformMode = TransformMode_NoRotationOrReflection;
		else if (strcmp(transformMode, ""noScale"") == 0)
			data->_transformMode = TransformMode_NoScale;
		else if (strcmp(transformMode, ""noScaleOrReflection"") == 0)
			data->_transformMode = TransformMode_NoScaleOrReflection;
		data->_skinRequired = Json::getBoolean(boneMap, ""skin"", false);

		const char *color = Json::getString(boneMap, ""color"", NULL);
		if (color) toColor(data->getColor(), color, true);

		skeletonData->_bones[i] = data;
		bonesCount++;
	}

	/* Slots. */
	slots = Json::getItem(root, ""slots"");
	if (slots) {
		Json *slotMap;
		skeletonData->_slots.ensureCapacity(slots->_size);
		skeletonData->_slots.setSize(slots->_size, 0);
		for (slotMap = slots->_child, i = 0; slotMap; slotMap = slotMap->_next, ++i) {
			SlotData *data;
			const char *color;
			const char *dark;
			Json *item;

			const char *boneName = Json::getString(slotMap, ""bone"", 0);
			BoneData *boneData = skeletonData->findBone(boneName);
			if (!boneData) {
				delete skeletonData;
				setError(root, ""Slot bone not found: "", boneName);
				return NULL;
			}

			data = new (__FILE__, __LINE__) SlotData(i, Json::getString(slotMap, ""name"", 0), *boneData);

			color = Json::getString(slotMap, ""color"", 0);
			if (color) {
				Color &c = data->getColor();
				c.r = toColor(color, 0);
				c.g = toColor(color, 1);
				c.b = toColor(color, 2);
				c.a = toColor(color, 3);
			}

			dark = Json::getString(slotMap, ""dark"", 0);
			if (dark) {
				Color &darkColor = data->getDarkColor();
				darkColor.r = toColor(dark, 0);
				darkColor.g = toColor(dark, 1);
				darkColor.b = toColor(dark, 2);
				darkColor.a = 1;
				data->setHasDarkColor(true);
			}

			item = Json::getItem(slotMap, ""attachment"");
			if (item) data->setAttachmentName(item->_valueString);

			item = Json::getItem(slotMap, ""blend"");
			if (item) {
				if (strcmp(item->_valueString, ""additive"") == 0) data->_blendMode = BlendMode_Additive;
				else if (strcmp(item->_valueString, ""multiply"") == 0)
					data->_blendMode = BlendMode_Multiply;
				else if (strcmp(item->_valueString, ""screen"") == 0)
					data->_blendMode = BlendMode_Screen;
			}

			skeletonData->_slots[i] = data;
		}
	}

	/* IK constraints. */
	ik = Json::getItem(root, ""ik"");
	if (ik) {
		Json *constraintMap;
		skeletonData->_ikConstraints.ensureCapacity(ik->_size);
		skeletonData->_ikConstraints.setSize(ik->_size, 0);
		for (constraintMap = ik->_child, i = 0; constraintMap; constraintMap = constraintMap->_next, ++i) {
			const char *targetName;

			IkConstraintData *data = new (__FILE__, __LINE__) IkConstraintData(
					Json::getString(constraintMap, ""name"", 0));
			data->setOrder(Json::getInt(constraintMap, ""order"", 0));
			data->setSkinRequired(Json::getBoolean(constraintMap, ""skin"", false));

			boneMap = Json::getItem(constraintMap, ""bones"");
			data->_bones.ensureCapacity(boneMap->_size);
			data->_bones.setSize(boneMap->_size, 0);
			for (boneMap = boneMap->_child, ii = 0; boneMap; boneMap = boneMap->_next, ++ii) {
				data->_bones[ii] = skeletonData->findBone(boneMap->_valueString);
				if (!data->_bones[ii]) {
					delete skeletonData;
					setError(root, ""IK bone not found: "", boneMap->_valueString);
					return NULL;
				}
			}

			targetName = Json::getString(constraintMap, ""target"", 0);
			data->_target = skeletonData->findBone(targetName);
			if (!data->_target) {
				delete skeletonData;
				setError(root, ""Target bone not found: "", targetName);
				return NULL;
			}

			data->_mix = Json::getFloat(constraintMap, ""mix"", 1);
			data->_softness = Json::getFloat(constraintMap, ""softness"", 0) * _scale;
			data->_bendDirection = Json::getInt(constraintMap, ""bendPositive"", 1) ? 1 : -1;
			data->_compress = Json::getInt(constraintMap, ""compress"", 0) ? true : false;
			data->_stretch = Json::getInt(constraintMap, ""stretch"", 0) ? true : false;
			data->_uniform = Json::getInt(constraintMap, ""uniform"", 0) ? true : false;

			skeletonData->_ikConstraints[i] = data;
		}
	}

	/* Transform constraints. */
	transform = Json::getItem(root, ""transform"");
	if (transform) {
		Json *constraintMap;
		skeletonData->_transformConstraints.ensureCapacity(transform->_size);
		skeletonData->_transformConstraints.setSize(transform->_size, 0);
		for (constraintMap = transform->_child, i = 0; constraintMap; constraintMap = constraintMap->_next, ++i) {
			const char *name;

			TransformConstraintData *data = new (__FILE__, __LINE__) TransformConstraintData(
					Json::getString(constraintMap, ""name"", 0));
			data->setOrder(Json::getInt(constraintMap, ""order"", 0));
			data->setSkinRequired(Json::getBoolean(constraintMap, ""skin"", false));

			boneMap = Json::getItem(constraintMap, ""bones"");
			data->_bones.ensureCapacity(boneMap->_size);
			data->_bones.setSize(boneMap->_size, 0);
			for (boneMap = boneMap->_child, ii = 0; boneMap; boneMap = boneMap->_next, ++ii) {
				data->_bones[ii] = skeletonData->findBone(boneMap->_valueString);
				if (!data->_bones[ii]) {
					delete skeletonData;
					setError(root, ""Transform bone not found: "", boneMap->_valueString);
					return NULL;
				}
			}

			name = Json::getString(constraintMap, ""target"", 0);
			data->_target = skeletonData->findBone(name);
			if (!data->_target) {
				delete skeletonData;
				setError(root, ""Target bone not found: "", name);
				return NULL;
			}

			data->_local = Json::getInt(constraintMap, ""local"", 0) ? true : false;
			data->_relative = Json::getInt(constraintMap, ""relative"", 0) ? true : false;
			data->_offsetRotation = Json::getFloat(constraintMap, ""rotation"", 0);
			data->_offsetX = Json::getFloat(constraintMap, ""x"", 0) * _scale;
			data->_offsetY = Json::getFloat(constraintMap, ""y"", 0) * _scale;
			data->_offsetScaleX = Json::getFloat(constraintMap, ""scaleX"", 0);
			data->_offsetScaleY = Json::getFloat(constraintMap, ""scaleY"", 0);
			data->_offsetShearY = Json::getFloat(constraintMap, ""shearY"", 0);

			data->_mixRotate = Json::getFloat(constraintMap, ""mixRotate"", 1);
			data->_mixX = Json::getFloat(constraintMap, ""mixX"", 1);
			data->_mixY = Json::getFloat(constraintMap, ""mixY"", data->_mixX);
			data->_mixScaleX = Json::getFloat(constraintMap, ""mixScaleX"", 1);
			data->_mixScaleY = Json::getFloat(constraintMap, ""mixScaleY"", data->_mixScaleX);
			data->_mixShearY = Json::getFloat(constraintMap, ""mixShearY"", 1);

			skeletonData->_transformConstraints[i] = data;
		}
	}

	/* Path constraints */
	path = Json::getItem(root, ""path"");
	if (path) {
		Json *constraintMap;
		skeletonData->_pathConstraints.ensureCapacity(path->_size);
		skeletonData->_pathConstraints.setSize(path->_size, 0);
		for (constraintMap = path->_child, i = 0; constraintMap; constraintMap = constraintMap->_next, ++i) {
			const char *name;
			const char *item;

			PathConstraintData *data = new (__FILE__, __LINE__) PathConstraintData(
					Json::getString(constraintMap, ""name"", 0));
			data->setOrder(Json::getInt(constraintMap, ""order"", 0));
			data->setSkinRequired(Json::getBoolean(constraintMap, ""skin"", false));

			boneMap = Json::getItem(constraintMap, ""bones"");
			data->_bones.ensureCapacity(boneMap->_size);
			data->_bones.setSize(boneMap->_size, 0);
			for (boneMap = boneMap->_child, ii = 0; boneMap; boneMap = boneMap->_next, ++ii) {
				data->_bones[ii] = skeletonData->findBone(boneMap->_valueString);
				if (!data->_bones[ii]) {
					delete skeletonData;
					setError(root, ""Path bone not found: "", boneMap->_valueString);
					return NULL;
				}
			}

			name = Json::getString(constraintMap, ""target"", 0);
			data->_target = skeletonData->findSlot(name);
			if (!data->_target) {
				delete skeletonData;
				setError(root, ""Target slot not found: "", name);
				return NULL;
			}

			item = Json::getString(constraintMap, ""positionMode"", ""percent"");
			if (strcmp(item, ""fixed"") == 0) {
				data->_positionMode = PositionMode_Fixed;
			} else if (strcmp(item, ""percent"") == 0) {
				data->_positionMode = PositionMode_Percent;
			}

			item = Json::getString(constraintMap, ""spacingMode"", ""length"");
			if (strcmp(item, ""length"") == 0) data->_spacingMode = SpacingMode_Length;
			else if (strcmp(item, ""fixed"") == 0)
				data->_spacingMode = SpacingMode_Fixed;
			else if (strcmp(item, ""percent"") == 0)
				data->_spacingMode = SpacingMode_Percent;

			item = Json::getString(constraintMap, ""rotateMode"", ""tangent"");
			if (strcmp(item, ""tangent"") == 0) data->_rotateMode = RotateMode_Tangent;
			else if (strcmp(item, ""chain"") == 0)
				data->_rotateMode = RotateMode_Chain;
			else if (strcmp(item, ""chainScale"") == 0)
				data->_rotateMode = RotateMode_ChainScale;

			data->_offsetRotation = Json::getFloat(constraintMap, ""rotation"", 0);
			data->_position = Json::getFloat(constraintMap, ""position"", 0);
			if (data->_positionMode == PositionMode_Fixed) data->_position *= _scale;
			data->_spacing = Json::getFloat(constraintMap, ""spacing"", 0);
			if (data->_spacingMode == SpacingMode_Length || data->_spacingMode == SpacingMode_Fixed)
				data->_spacing *= _scale;
			data->_mixRotate = Json::getFloat(constraintMap, ""mixRotate"", 1);
			data->_mixX = Json::getFloat(constraintMap, ""mixX"", 1);
			data->_mixY = Json::getFloat(constraintMap, ""mixY"", data->_mixX);

			skeletonData->_pathConstraints[i] = data;
		}
	}

	/* Skins. */
	skins = Json::getItem(root, ""skins"");
	if (skins) {
		Json *skinMap;
		skeletonData->_skins.ensureCapacity(skins->_size);
		skeletonData->_skins.setSize(skins->_size, 0);
		int skinsIndex = 0;
		for (skinMap = skins->_child, i = 0; skinMap; skinMap = skinMap->_next, ++i) {
			Json *attachmentsMap;
			Json *curves;

			Skin *skin = new (__FILE__, __LINE__) Skin(Json::getString(skinMap, ""name"", """"));

			Json *item = Json::getItem(skinMap, ""bones"");
			if (item) {
				for (item = item->_child; item; item = item->_next) {
					BoneData *data = skeletonData->findBone(item->_valueString);
					if (!data) {
						delete skeletonData;
						setError(root, String(""Skin bone not found: ""), item->_valueString);
						return NULL;
					}
					skin->getBones().add(data);
				}
			}

			item = Json::getItem(skinMap, ""ik"");
			if (item) {
				for (item = item->_child; item; item = item->_next) {
					IkConstraintData *data = skeletonData->findIkConstraint(item->_valueString);
					if (!data) {
						delete skeletonData;
						setError(root, String(""Skin IK constraint not found: ""), item->_valueString);
						return NULL;
					}
					skin->getConstraints().add(data);
				}
			}

			item = Json::getItem(skinMap, ""transform"");
			if (item) {
				for (item = item->_child; item; item = item->_next) {
					TransformConstraintData *data = skeletonData->findTransformConstraint(item->_valueString);
					if (!data) {
						delete skeletonData;
						setError(root, String(""Skin transform constraint not found: ""), item->_valueString);
						return NULL;
					}
					skin->getConstraints().add(data);
				}
			}

			item = Json::getItem(skinMap, ""path"");
			if (item) {
				for (item = item->_child; item; item = item->_next) {
					PathConstraintData *data = skeletonData->findPathConstraint(item->_valueString);
					if (!data) {
						delete skeletonData;
						setError(root, String(""Skin path constraint not found: ""), item->_valueString);
						return NULL;
					}
					skin->getConstraints().add(data);
				}
			}

			skeletonData->_skins[skinsIndex++] = skin;
			if (strcmp(Json::getString(skinMap, ""name"", """"), ""default"") == 0) {
				skeletonData->_defaultSkin = skin;
			}

			for (attachmentsMap = Json::getItem(skinMap,
												""attachments"")
										  ->_child;
				 attachmentsMap; attachmentsMap = attachmentsMap->_next) {
				SlotData *slot = skeletonData->findSlot(attachmentsMap->_name);
				Json *attachmentMap;

				for (attachmentMap = attachmentsMap->_child; attachmentMap; attachmentMap = attachmentMap->_next) {
					Attachment *attachment = NULL;
					const char *skinAttachmentName = attachmentMap->_name;
					const char *attachmentName = Json::getString(attachmentMap, ""name"", skinAttachmentName);
					const char *attachmentPath = Json::getString(attachmentMap, ""path"", attachmentName);
					const char *color;
					Json *entry;

					const char *typeString = Json::getString(attachmentMap, ""type"", ""region"");
					AttachmentType type;
					if (strcmp(typeString, ""region"") == 0) type = AttachmentType_Region;
					else if (strcmp(typeString, ""mesh"") == 0)
						type = AttachmentType_Mesh;
					else if (strcmp(typeString, ""linkedmesh"") == 0)
						type = AttachmentType_Linkedmesh;
					else if (strcmp(typeString, ""boundingbox"") == 0)
						type = AttachmentType_Boundingbox;
					else if (strcmp(typeString, ""path"") == 0)
						type = AttachmentType_Path;
					else if (strcmp(typeString, ""clipping"") == 0)
						type = AttachmentType_Clipping;
					else if (strcmp(typeString, ""point"") == 0)
						type = AttachmentType_Point;
					else {
						delete skeletonData;
						setError(root, ""Unknown attachment type: "", typeString);
						return NULL;
					}

					switch (type) {
						case AttachmentType_Region: {
							attachment = _attachmentLoader->newRegionAttachment(*skin, attachmentName, attachmentPath);
							if (!attachment) {
								delete skeletonData;
								setError(root, ""Error reading attachment: "", skinAttachmentName);
								return NULL;
							}

							RegionAttachment *region = static_cast<RegionAttachment *>(attachment);
							region->_path = attachmentPath;

							region->_x = Json::getFloat(attachmentMap, ""x"", 0) * _scale;
							region->_y = Json::getFloat(attachmentMap, ""y"", 0) * _scale;
							region->_scaleX = Json::getFloat(attachmentMap, ""scaleX"", 1);
							region->_scaleY = Json::getFloat(attachmentMap, ""scaleY"", 1);
							region->_rotation = Json::getFloat(attachmentMap, ""rotation"", 0);
							region->_width = Json::getFloat(attachmentMap, ""width"", 32) * _scale;
							region->_height = Json::getFloat(attachmentMap, ""height"", 32) * _scale;

							color = Json::getString(attachmentMap, ""color"", 0);
							if (color) toColor(region->getColor(), color, true);

							region->updateOffset();
							_attachmentLoader->configureAttachment(region);
							break;
						}
						case AttachmentType_Mesh:
						case AttachmentType_Linkedmesh: {
							attachment = _attachmentLoader->newMeshAttachment(*skin, attachmentName, attachmentPath);

							if (!attachment) {
								delete skeletonData;
								setError(root, ""Error reading attachment: "", skinAttachmentName);
								return NULL;
							}

							MeshAttachment *mesh = static_cast<MeshAttachment *>(attachment);
							mesh->_path = attachmentPath;

							color = Json::getString(attachmentMap, ""color"", 0);
							if (color) toColor(mesh->getColor(), color, true);

							mesh->_width = Json::getFloat(attachmentMap, ""width"", 32) * _scale;
							mesh->_height = Json::getFloat(attachmentMap, ""height"", 32) * _scale;

							entry = Json::getItem(attachmentMap, ""parent"");
							if (!entry) {
								int verticesLength;
								entry = Json::getItem(attachmentMap, ""triangles"");
								mesh->_triangles.ensureCapacity(entry->_size);
								mesh->_triangles.setSize(entry->_size, 0);
								for (entry = entry->_child, ii = 0; entry; entry = entry->_next, ++ii)
									mesh->_triangles[ii] = (unsigned short) entry->_valueInt;

								entry = Json::getItem(attachmentMap, ""uvs"");
								verticesLength = entry->_size;
								mesh->_regionUVs.ensureCapacity(verticesLength);
								mesh->_regionUVs.setSize(verticesLength, 0);
								for (entry = entry->_child, ii = 0; entry; entry = entry->_next, ++ii)
									mesh->_regionUVs[ii] = entry->_valueFloat;

								readVertices(attachmentMap, mesh, verticesLength);

								mesh->updateUVs();

								mesh->_hullLength = Json::getInt(attachmentMap, ""hull"", 0);

								entry = Json::getItem(attachmentMap, ""edges"");
								if (entry) {
									mesh->_edges.ensureCapacity(entry->_size);
									mesh->_edges.setSize(entry->_size, 0);
									for (entry = entry->_child, ii = 0; entry; entry = entry->_next, ++ii)
										mesh->_edges[ii] = entry->_valueInt;
								}
								_attachmentLoader->configureAttachment(mesh);
							} else {
								bool inheritDeform = Json::getInt(attachmentMap, ""deform"", 1) ? true : false;
								LinkedMesh *linkedMesh = new (__FILE__, __LINE__) LinkedMesh(mesh,
																							 String(Json::getString(
																									 attachmentMap,
																									 ""skin"", 0)),
																							 slot->getIndex(),
																							 String(entry->_valueString),
																							 inheritDeform);
								_linkedMeshes.add(linkedMesh);
							}
							break;
						}
						case AttachmentType_Boundingbox: {
							attachment = _attachmentLoader->newBoundingBoxAttachment(*skin, attachmentName);

							BoundingBoxAttachment *box = static_cast<BoundingBoxAttachment *>(attachment);

							int vertexCount = Json::getInt(attachmentMap, ""vertexCount"", 0) << 1;
							readVertices(attachmentMap, box, vertexCount);
							color = Json::getString(attachmentMap, ""color"", NULL);
							if (color) toColor(box->getColor(), color, true);
							_attachmentLoader->configureAttachment(attachment);
							break;
						}
						case AttachmentType_Path: {
							attachment = _attachmentLoader->newPathAttachment(*skin, attachmentName);

							PathAttachment *pathAttatchment = static_cast<PathAttachment *>(attachment);

							int vertexCount = 0;
							pathAttatchment->_closed = Json::getInt(attachmentMap, ""closed"", 0) ? true : false;
							pathAttatchment->_constantSpeed = Json::getInt(attachmentMap, ""constantSpeed"", 1) ? true
																											  : false;
							vertexCount = Json::getInt(attachmentMap, ""vertexCount"", 0);
							readVertices(attachmentMap, pathAttatchment, vertexCount << 1);

							pathAttatchment->_lengths.ensureCapacity(vertexCount / 3);
							pathAttatchment->_lengths.setSize(vertexCount / 3, 0);

							curves = Json::getItem(attachmentMap, ""lengths"");
							for (curves = curves->_child, ii = 0; curves; curves = curves->_next, ++ii)
								pathAttatchment->_lengths[ii] = curves->_valueFloat * _scale;
							color = Json::getString(attachmentMap, ""color"", NULL);
							if (color) toColor(pathAttatchment->getColor(), color, true);
							_attachmentLoader->configureAttachment(attachment);
							break;
						}
						case AttachmentType_Point: {
							attachment = _attachmentLoader->newPointAttachment(*skin, attachmentName);

							PointAttachment *point = static_cast<PointAttachment *>(attachment);

							point->_x = Json::getFloat(attachmentMap, ""x"", 0) * _scale;
							point->_y = Json::getFloat(attachmentMap, ""y"", 0) * _scale;
							point->_rotation = Json::getFloat(attachmentMap, ""rotation"", 0);
							color = Json::getString(attachmentMap, ""color"", NULL);
							if (color) toColor(point->getColor(), color, true);
							_attachmentLoader->configureAttachment(attachment);
							break;
						}
						case AttachmentType_Clipping: {
							attachment = _attachmentLoader->newClippingAttachment(*skin, attachmentName);

							ClippingAttachment *clip = static_cast<ClippingAttachment *>(attachment);

							int vertexCount = 0;
							const char *end = Json::getString(attachmentMap, ""end"", 0);
							if (end) clip->_endSlot = skeletonData->findSlot(end);
							vertexCount = Json::getInt(attachmentMap, ""vertexCount"", 0) << 1;
							readVertices(attachmentMap, clip, vertexCount);
							color = Json::getString(attachmentMap, ""color"", NULL);
							if (color) toColor(clip->getColor(), color, true);
							_attachmentLoader->configureAttachment(attachment);
							break;
						}
					}

					skin->setAttachment(slot->getIndex(), skinAttachmentName, attachment);
				}
			}
		}
	}

	/* Linked meshes. */
	int n = _linkedMeshes.size();
	for (i = 0; i < n; ++i) {
		LinkedMesh *linkedMesh = _linkedMeshes[i];
		Skin *skin = linkedMesh->_skin.length() == 0 ? skeletonData->getDefaultSkin() : skeletonData->findSkin(linkedMesh->_skin);
		if (skin == NULL) {
			delete skeletonData;
			setError(root, ""Skin not found: "", linkedMesh->_skin.buffer());
			return NULL;
		}
		Attachment *parent = skin->getAttachment(linkedMesh->_slotIndex, linkedMesh->_parent);
		if (parent == NULL) {
			delete skeletonData;
			setError(root, ""Parent mesh not found: "", linkedMesh->_parent.buffer());
			return NULL;
		}
		linkedMesh->_mesh->_deformAttachment = linkedMesh->_inheritDeform ? static_cast<VertexAttachment *>(parent)
																		  : linkedMesh->_mesh;
		linkedMesh->_mesh->setParentMesh(static_cast<MeshAttachment *>(parent));
		linkedMesh->_mesh->updateUVs();
		_attachmentLoader->configureAttachment(linkedMesh->_mesh);
	}
	ContainerUtil::cleanUpVectorOfPointers(_linkedMeshes);
	_linkedMeshes.clear();

	/* Events. */
	events = Json::getItem(root, ""events"");
	if (events) {
		Json *eventMap;
		skeletonData->_events.ensureCapacity(events->_size);
		skeletonData->_events.setSize(events->_size, 0);
		for (eventMap = events->_child, i = 0; eventMap; eventMap = eventMap->_next, ++i) {
			EventData *eventData = new (__FILE__, __LINE__) EventData(String(eventMap->_name));

			eventData->_intValue = Json::getInt(eventMap, ""int"", 0);
			eventData->_floatValue = Json::getFloat(eventMap, ""float"", 0);
			const char *stringValue = Json::getString(eventMap, ""string"", 0);
			eventData->_stringValue = stringValue;
			const char *audioPath = Json::getString(eventMap, ""audio"", 0);
			eventData->_audioPath = audioPath;
			if (audioPath) {
				eventData->_volume = Json::getFloat(eventMap, ""volume"", 1);
				eventData->_balance = Json::getFloat(eventMap, ""balance"", 0);
			}
			skeletonData->_events[i] = eventData;
		}
	}

	/* Animations. */
	animations = Json::getItem(root, ""animations"");
	if (animations) {
		Json *animationMap;
		skeletonData->_animations.ensureCapacity(animations->_size);
		skeletonData->_animations.setSize(animations->_size, 0);
		int animationsIndex = 0;
		for (animationMap = animations->_child; animationMap; animationMap = animationMap->_next) {
			Animation *animation = readAnimation(animationMap, skeletonData);
			if (!animation) {
				delete skeletonData;
				delete root;
				return NULL;
			}
			skeletonData->_animations[animationsIndex++] = animation;
		}
	}

	delete root;

	return skeletonData;
}

void SkeletonJson::setBezier(CurveTimeline *timeline, int frame, int value, int bezier, float time1, float value1, float cx1,
							 float cy1,
							 float cx2, float cy2, float time2, float value2) {
	timeline->setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
}

int SkeletonJson::readCurve(Json *curve, CurveTimeline *timeline, int bezier, int frame, int value, float time1,
							float time2,
							float value1, float value2, float scale) {
	if (curve->_type == Json::JSON_STRING && strcmp(curve->_valueString, ""stepped"") == 0) {
		timeline->setStepped(frame);
		return bezier;
	}
	curve = Json::getItem(curve, value << 2);
	float cx1 = curve->_valueFloat;
	curve = curve->_next;
	float cy1 = curve->_valueFloat * scale;
	curve = curve->_next;
	float cx2 = curve->_valueFloat;
	curve = curve->_next;
	float cy2 = curve->_valueFloat * scale;
	setBezier(timeline, frame, value, bezier, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
	return bezier + 1;
}

Timeline *SkeletonJson::readTimeline(Json *keyMap, CurveTimeline1 *timeline, float defaultValue, float scale) {
	float time = Json::getFloat(keyMap, ""time"", 0);
	float value = Json::getFloat(keyMap, ""value"", defaultValue) * scale;
	int bezier = 0;
	for (int frame = 0;; frame++) {
		timeline->setFrame(frame, time, value);
		Json *nextMap = keyMap->_next;
		if (!nextMap) break;
		float time2 = Json::getFloat(nextMap, ""time"", 0);
		float value2 = Json::getFloat(nextMap, ""value"", defaultValue) * scale;
		Json *curve = Json::getItem(keyMap, ""curve"");
		if (curve != NULL) bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, value, value2, scale);
		time = time2;
		value = value2;
		keyMap = nextMap;
	}
	// timeline.shrink(); // BOZO
	return timeline;
}

Timeline *SkeletonJson::readTimeline(Json *keyMap, CurveTimeline2 *timeline, const char *name1, const char *name2,
									 float defaultValue, float scale) {
	float time = Json::getFloat(keyMap, ""time"", 0);
	float value1 = Json::getFloat(keyMap, name1, defaultValue) * scale;
	float value2 = Json::getFloat(keyMap, name2, defaultValue) * scale;
	int bezier = 0;
	for (int frame = 0;; frame++) {
		timeline->setFrame(frame, time, value1, value2);
		Json *nextMap = keyMap->_next;
		if (!nextMap) break;
		float time2 = Json::getFloat(nextMap, ""time"", 0);
		float nvalue1 = Json::getFloat(nextMap, name1, defaultValue) * scale;
		float nvalue2 = Json::getFloat(nextMap, name2, defaultValue) * scale;
		Json *curve = Json::getItem(keyMap, ""curve"");
		if (curve != NULL) {
			bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, value1, nvalue1, scale);
			bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, value2, nvalue2, scale);
		}
		time = time2;
		value1 = nvalue1;
		value2 = nvalue2;
		keyMap = nextMap;
	}
	// timeline.shrink(); // BOZO
	return timeline;
}

int SkeletonJson::findSlotIndex(SkeletonData *skeletonData, const String &slotName, Vector<Timeline *> timelines) {
	int slotIndex = ContainerUtil::findIndexWithName(skeletonData->getSlots(), slotName);
	if (slotIndex == -1) {
		ContainerUtil::cleanUpVectorOfPointers(timelines);
		setError(NULL, ""Slot not found: "", slotName);
	}
	return slotIndex;
}

Animation *SkeletonJson::readAnimation(Json *root, SkeletonData *skeletonData) {
	Vector<Timeline *> timelines;
	Json *bones = Json::getItem(root, ""bones"");
	Json *slots = Json::getItem(root, ""slots"");
	Json *ik = Json::getItem(root, ""ik"");
	Json *transform = Json::getItem(root, ""transform"");
	Json *paths = Json::getItem(root, ""path"");
	Json *deform = Json::getItem(root, ""deform"");
	Json *drawOrder = Json::getItem(root, ""drawOrder"");
	Json *events = Json::getItem(root, ""events"");
	Json *boneMap, *slotMap, *constraintMap, *keyMap, *nextMap, *curve;
	int frame, bezier;
	Color color, color2, newColor, newColor2;

	/** Slot timelines. */
	for (slotMap = slots ? slots->_child : 0; slotMap; slotMap = slotMap->_next) {
		int slotIndex = findSlotIndex(skeletonData, slotMap->_name, timelines);
		if (slotIndex == -1) return NULL;

		for (Json *timelineMap = slotMap->_child; timelineMap; timelineMap = timelineMap->_next) {
			int frames = timelineMap->_size;
			if (strcmp(timelineMap->_name, ""attachment"") == 0) {
				AttachmentTimeline *timeline = new (__FILE__, __LINE__) AttachmentTimeline(frames, slotIndex);
				for (keyMap = timelineMap->_child, frame = 0; keyMap; keyMap = keyMap->_next, ++frame) {
					timeline->setFrame(frame, Json::getFloat(keyMap, ""time"", 0),
									   Json::getItem(keyMap, ""name"")->_valueString);
				}
				timelines.add(timeline);

			} else if (strcmp(timelineMap->_name, ""rgba"") == 0) {
				RGBATimeline *timeline = new (__FILE__, __LINE__) RGBATimeline(frames, frames << 2, slotIndex);
				keyMap = timelineMap->_child;
				float time = Json::getFloat(keyMap, ""time"", 0);
				toColor(color, Json::getString(keyMap, ""color"", 0), true);

				for (frame = 0, bezier = 0;; ++frame) {
					timeline->setFrame(frame, time, color.r, color.g, color.b, color.a);
					nextMap = keyMap->_next;
					if (!nextMap) {
						// timeline.shrink(); // BOZO
						break;
					}
					float time2 = Json::getFloat(nextMap, ""time"", 0);
					toColor(newColor, Json::getString(nextMap, ""color"", 0), true);
					curve = Json::getItem(keyMap, ""curve"");
					if (curve) {
						bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, color.r, newColor.r, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, color.g, newColor.g, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 2, time, time2, color.b, newColor.b, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 3, time, time2, color.a, newColor.a, 1);
					}
					time = time2;
					color = newColor;
					keyMap = nextMap;
				}
				timelines.add(timeline);
			} else if (strcmp(timelineMap->_name, ""rgb"") == 0) {
				RGBTimeline *timeline = new (__FILE__, __LINE__) RGBTimeline(frames, frames * 3, slotIndex);
				keyMap = timelineMap->_child;
				float time = Json::getFloat(keyMap, ""time"", 0);
				toColor(color, Json::getString(keyMap, ""color"", 0), false);

				for (frame = 0, bezier = 0;; ++frame) {
					timeline->setFrame(frame, time, color.r, color.g, color.b);
					nextMap = keyMap->_next;
					if (!nextMap) {
						// timeline.shrink(); // BOZO
						break;
					}
					float time2 = Json::getFloat(nextMap, ""time"", 0);
					toColor(newColor, Json::getString(nextMap, ""color"", 0), false);
					curve = Json::getItem(keyMap, ""curve"");
					if (curve) {
						bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, color.r, newColor.r, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, color.g, newColor.g, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 2, time, time2, color.b, newColor.b, 1);
					}
					time = time2;
					color = newColor;
					keyMap = nextMap;
				}
				timelines.add(timeline);
			} else if (strcmp(timelineMap->_name, ""alpha"") == 0) {
				timelines.add(readTimeline(timelineMap->_child,
										   new (__FILE__, __LINE__) AlphaTimeline(frames, frames, slotIndex),
										   0, 1));
			} else if (strcmp(timelineMap->_name, ""rgba2"") == 0) {
				RGBA2Timeline *timeline = new (__FILE__, __LINE__) RGBA2Timeline(frames, frames * 7, slotIndex);
				keyMap = timelineMap->_child;
				float time = Json::getFloat(keyMap, ""time"", 0);
				toColor(color, Json::getString(keyMap, ""light"", 0), true);
				toColor(color2, Json::getString(keyMap, ""dark"", 0), false);

				for (frame = 0, bezier = 0;; ++frame) {
					timeline->setFrame(frame, time, color.r, color.g, color.b, color.a, color2.g, color2.g, color2.b);
					nextMap = keyMap->_next;
					if (!nextMap) {
						// timeline.shrink(); // BOZO
						break;
					}
					float time2 = Json::getFloat(nextMap, ""time"", 0);
					toColor(newColor, Json::getString(nextMap, ""light"", 0), true);
					toColor(newColor2, Json::getString(nextMap, ""dark"", 0), false);
					curve = Json::getItem(keyMap, ""curve"");
					if (curve) {
						bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, color.r, newColor.r, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, color.g, newColor.g, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 2, time, time2, color.b, newColor.b, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 3, time, time2, color.a, newColor.a, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 4, time, time2, color2.r, newColor2.r, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 5, time, time2, color2.g, newColor2.g, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 6, time, time2, color2.b, newColor2.b, 1);
					}
					time = time2;
					color = newColor;
					color2 = newColor2;
					keyMap = nextMap;
				}
				timelines.add(timeline);
			} else if (strcmp(timelineMap->_name, ""rgb2"") == 0) {
				RGBA2Timeline *timeline = new (__FILE__, __LINE__) RGBA2Timeline(frames, frames * 6, slotIndex);
				keyMap = timelineMap->_child;
				float time = Json::getFloat(keyMap, ""time"", 0);
				toColor(color, Json::getString(keyMap, ""light"", 0), false);
				toColor(color2, Json::getString(keyMap, ""dark"", 0), false);

				for (frame = 0, bezier = 0;; ++frame) {
					timeline->setFrame(frame, time, color.r, color.g, color.b, color.a, color2.r, color2.g, color2.b);
					nextMap = keyMap->_next;
					if (!nextMap) {
						// timeline.shrink(); // BOZO
						break;
					}
					float time2 = Json::getFloat(nextMap, ""time"", 0);
					toColor(newColor, Json::getString(nextMap, ""light"", 0), false);
					toColor(newColor2, Json::getString(nextMap, ""dark"", 0), false);
					curve = Json::getItem(keyMap, ""curve"");
					if (curve) {
						bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, color.r, newColor.r, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, color.g, newColor.g, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 2, time, time2, color.b, newColor.b, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 3, time, time2, color2.r, newColor2.r, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 4, time, time2, color2.g, newColor2.g, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 5, time, time2, color2.b, newColor2.b, 1);
					}
					time = time2;
					color = newColor;
					color2 = newColor2;
					keyMap = nextMap;
				}
				timelines.add(timeline);
			} else {
				ContainerUtil::cleanUpVectorOfPointers(timelines);
				setError(NULL, ""Invalid timeline type for a slot: "", timelineMap->_name);
				return NULL;
			}
		}
	}

	/** Bone timelines. */
	for (boneMap = bones ? bones->_child : 0; boneMap; boneMap = boneMap->_next) {
		int boneIndex = ContainerUtil::findIndexWithName(skeletonData->_bones, boneMap->_name);
		if (boneIndex == -1) {
			ContainerUtil::cleanUpVectorOfPointers(timelines);
			setError(NULL, ""Bone not found: "", boneMap->_name);
			return NULL;
		}

		for (Json *timelineMap = boneMap->_child; timelineMap; timelineMap = timelineMap->_next) {
			int frames = timelineMap->_size;
			if (frames == 0) continue;

			if (strcmp(timelineMap->_name, ""rotate"") == 0) {
				timelines.add(readTimeline(timelineMap->_child,
										   new RotateTimeline(frames, frames, boneIndex), 0,
										   1));
			} else if (strcmp(timelineMap->_name, ""translate"") == 0) {
				TranslateTimeline *timeline = new TranslateTimeline(frames, frames << 1,
																	boneIndex);
				timelines.add(readTimeline(timelineMap->_child, timeline, ""x"", ""y"", 0, _scale));
			} else if (strcmp(timelineMap->_name, ""translatex"") == 0) {
				TranslateXTimeline *timeline = new TranslateXTimeline(frames, frames,
																	  boneIndex);
				timelines.add(readTimeline(timelineMap->_child, timeline, 0, _scale));
			} else if (strcmp(timelineMap->_name, ""translatey"") == 0) {
				TranslateYTimeline *timeline = new TranslateYTimeline(frames, frames,
																	  boneIndex);
				timelines.add(readTimeline(timelineMap->_child, timeline, 0, _scale));
			} else if (strcmp(timelineMap->_name, ""scale"") == 0) {
				ScaleTimeline *timeline = new (__FILE__, __LINE__) ScaleTimeline(frames,
																				 frames << 1, boneIndex);
				timelines.add(readTimeline(timelineMap->_child, timeline, ""x"", ""y"", 1, 1));
			} else if (strcmp(timelineMap->_name, ""scalex"") == 0) {
				ScaleXTimeline *timeline = new (__FILE__, __LINE__) ScaleXTimeline(frames,
																				   frames, boneIndex);
				timelines.add(readTimeline(timelineMap->_child, timeline, 1, 1));
			} else if (strcmp(timelineMap->_name, ""scaley"") == 0) {
				ScaleYTimeline *timeline = new (__FILE__, __LINE__) ScaleYTimeline(frames,
																				   frames, boneIndex);
				timelines.add(readTimeline(timelineMap->_child, timeline, 1, 1));
			} else if (strcmp(timelineMap->_name, ""shear"") == 0) {
				ShearTimeline *timeline = new (__FILE__, __LINE__) ShearTimeline(frames,
																				 frames << 1, boneIndex);
				timelines.add(readTimeline(timelineMap->_child, timeline, ""x"", ""y"", 0, 1));
			} else if (strcmp(timelineMap->_name, ""shearx"") == 0) {
				ShearXTimeline *timeline = new (__FILE__, __LINE__) ShearXTimeline(frames,
																				   frames, boneIndex);
				timelines.add(readTimeline(timelineMap->_child, timeline, 0, 1));
			} else if (strcmp(timelineMap->_name, ""sheary"") == 0) {
				ShearYTimeline *timeline = new (__FILE__, __LINE__) ShearYTimeline(frames,
																				   frames, boneIndex);
				timelines.add(readTimeline(timelineMap->_child, timeline, 0, 1));
			} else {
				ContainerUtil::cleanUpVectorOfPointers(timelines);
				setError(NULL, ""Invalid timeline type for a bone: "", timelineMap->_name);
				return NULL;
			}
		}
	}

	/** IK constraint timelines. */
	for (constraintMap = ik ? ik->_child : 0; constraintMap; constraintMap = constraintMap->_next) {
		keyMap = constraintMap->_child;
		if (keyMap == NULL) continue;

		IkConstraintData *constraint = skeletonData->findIkConstraint(constraintMap->_name);
		int constraintIndex = skeletonData->_ikConstraints.indexOf(constraint);
		IkConstraintTimeline *timeline = new (__FILE__, __LINE__) IkConstraintTimeline(constraintMap->_size,
																					   constraintMap->_size << 1,
																					   constraintIndex);

		float time = Json::getFloat(keyMap, ""time"", 0);
		float mix = Json::getFloat(keyMap, ""mix"", 1);
		float softness = Json::getFloat(keyMap, ""softness"", 0) * _scale;

		for (frame = 0, bezier = 0;; frame++) {
			int bendDirection = Json::getBoolean(keyMap, ""bendPositive"", true) ? 1 : -1;
			timeline->setFrame(frame, time, mix, softness, bendDirection, Json::getBoolean(keyMap, ""compress"", false),
							   Json::getBoolean(keyMap, ""stretch"", false));
			nextMap = keyMap->_next;
			if (!nextMap) {
				// timeline.shrink(); // BOZO
				break;
			}

			float time2 = Json::getFloat(nextMap, ""time"", 0);
			float mix2 = Json::getFloat(nextMap, ""mix"", 1);
			float softness2 = Json::getFloat(nextMap, ""softness"", 0) * _scale;
			curve = Json::getItem(keyMap, ""curve"");
			if (curve) {
				bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, mix, mix2, 1);
				bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, softness, softness2, _scale);
			}

			time = time2;
			mix = mix2;
			softness = softness2;
			keyMap = nextMap;
		}

		timelines.add(timeline);
	}

	/** Transform constraint timelines. */
	for (constraintMap = transform ? transform->_child : 0; constraintMap; constraintMap = constraintMap->_next) {
		keyMap = constraintMap->_child;
		if (keyMap == NULL) continue;

		TransformConstraintData *constraint = skeletonData->findTransformConstraint(constraintMap->_name);
		int constraintIndex = skeletonData->_transformConstraints.indexOf(constraint);
		TransformConstraintTimeline *timeline = new (__FILE__, __LINE__) TransformConstraintTimeline(
				constraintMap->_size, constraintMap->_size << 2, constraintIndex);

		float time = Json::getFloat(keyMap, ""time"", 0);
		float mixRotate = Json::getFloat(keyMap, ""mixRotate"", 1);
		float mixShearY = Json::getFloat(keyMap, ""mixShearY"", 1);
		float mixX = Json::getFloat(keyMap, ""mixX"", 1);
		float mixY = Json::getFloat(keyMap, ""mixY"", mixX);
		float mixScaleX = Json::getFloat(keyMap, ""mixScaleX"", 1);
		float mixScaleY = Json::getFloat(keyMap, ""mixScaleY"", mixScaleX);

		for (frame = 0, bezier = 0;; frame++) {
			timeline->setFrame(frame, time, mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY);
			nextMap = keyMap->_next;
			if (!nextMap) {
				// timeline.shrink(); // BOZO
				break;
			}

			float time2 = Json::getFloat(nextMap, ""time"", 0);
			float mixRotate2 = Json::getFloat(nextMap, ""mixRotate"", 1);
			float mixShearY2 = Json::getFloat(nextMap, ""mixShearY"", 1);
			float mixX2 = Json::getFloat(nextMap, ""mixX"", 1);
			float mixY2 = Json::getFloat(nextMap, ""mixY"", mixX2);
			float mixScaleX2 = Json::getFloat(nextMap, ""mixScaleX"", 1);
			float mixScaleY2 = Json::getFloat(nextMap, ""mixScaleY"", mixScaleX2);
			curve = Json::getItem(keyMap, ""curve"");
			if (curve) {
				bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, mixRotate, mixRotate2, 1);
				bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, mixX, mixX2, 1);
				bezier = readCurve(curve, timeline, bezier, frame, 2, time, time2, mixY, mixY2, 1);
				bezier = readCurve(curve, timeline, bezier, frame, 3, time, time2, mixScaleX, mixScaleX2, 1);
				bezier = readCurve(curve, timeline, bezier, frame, 4, time, time2, mixScaleY, mixScaleY2, 1);
				bezier = readCurve(curve, timeline, bezier, frame, 5, time, time2, mixShearY, mixShearY2, 1);
			}

			time = time2;
			mixRotate = mixRotate2;
			mixX = mixX2;
			mixY = mixY2;
			mixScaleX = mixScaleX2;
			mixScaleY = mixScaleY2;
			mixScaleX = mixScaleX2;
			keyMap = nextMap;
		}

		timelines.add(timeline);
	}

	/** Path constraint timelines. */
	for (constraintMap = paths ? paths->_child : 0; constraintMap; constraintMap = constraintMap->_next) {
		PathConstraintData *constraint = skeletonData->findPathConstraint(constraintMap->_name);
		if (!constraint) {
			ContainerUtil::cleanUpVectorOfPointers(timelines);
			setError(NULL, ""Path constraint not found: "", constraintMap->_name);
			return NULL;
		}
		int constraintIndex = skeletonData->_pathConstraints.indexOf(constraint);
		for (Json *timelineMap = constraintMap->_child; timelineMap; timelineMap = timelineMap->_next) {
			keyMap = timelineMap->_child;
			if (keyMap == NULL) continue;
			const char *timelineName = timelineMap->_name;
			int frames = timelineMap->_size;
			if (strcmp(timelineName, ""position"") == 0) {
				PathConstraintPositionTimeline *timeline = new (__FILE__, __LINE__) PathConstraintPositionTimeline(
						frames, frames, constraintIndex);
				timelines.add(
						readTimeline(keyMap, timeline, 0, constraint->_positionMode == PositionMode_Fixed ? _scale : 1));
			} else if (strcmp(timelineName, ""spacing"") == 0) {
				CurveTimeline1 *timeline = new PathConstraintSpacingTimeline(frames, frames,
																			 constraintIndex);
				timelines.add(readTimeline(keyMap, timeline, 0,
										   constraint->_spacingMode == SpacingMode_Length ||
														   constraint->_spacingMode == SpacingMode_Fixed
												   ? _scale
												   : 1));
			} else if (strcmp(timelineName, ""mix"") == 0) {
				PathConstraintMixTimeline *timeline = new PathConstraintMixTimeline(frames,
																					frames * 3, constraintIndex);
				float time = Json::getFloat(keyMap, ""time"", 0);
				float mixRotate = Json::getFloat(keyMap, ""mixRotate"", 1);
				float mixX = Json::getFloat(keyMap, ""mixX"", 1);
				float mixY = Json::getFloat(keyMap, ""mixY"", mixX);
				for (frame = 0, bezier = 0;; frame++) {
					timeline->setFrame(frame, time, mixRotate, mixX, mixY);
					nextMap = keyMap->_next;
					if (!nextMap) {
						// timeline.shrink(); // BOZO
						break;
					}
					float time2 = Json::getFloat(nextMap, ""time"", 0);
					float mixRotate2 = Json::getFloat(nextMap, ""mixRotate"", 1);
					float mixX2 = Json::getFloat(nextMap, ""mixX"", 1);
					float mixY2 = Json::getFloat(nextMap, ""mixY"", mixX2);
					curve = Json::getItem(keyMap, ""curve"");
					if (curve != NULL) {
						bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, mixRotate, mixRotate2, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, mixX, mixX2, 1);
						bezier = readCurve(curve, timeline, bezier, frame, 2, time, time2, mixY, mixY2, 1);
					}
					time = time2;
					mixRotate = mixRotate2;
					mixX = mixX2;
					mixY = mixY2;
					keyMap = nextMap;
				}
				timelines.add(timeline);
			}
		}
	}

	/** Deform timelines. */
	for (constraintMap = deform ? deform->_child : NULL; constraintMap; constraintMap = constraintMap->_next) {
		Skin *skin = skeletonData->findSkin(constraintMap->_name);
		for (slotMap = constraintMap->_child; slotMap; slotMap = slotMap->_next) {
			int slotIndex = findSlotIndex(skeletonData, slotMap->_name, timelines);
			if (slotIndex == -1) return NULL;

			for (Json *timelineMap = slotMap->_child; timelineMap; timelineMap = timelineMap->_next) {
				keyMap = timelineMap->_child;
				if (keyMap == NULL) continue;

				Attachment *baseAttachment = skin->getAttachment(slotIndex, timelineMap->_name);
				if (!baseAttachment) {
					ContainerUtil::cleanUpVectorOfPointers(timelines);
					setError(NULL, ""Attachment not found: "", timelineMap->_name);
					return NULL;
				}
				VertexAttachment *attachment = static_cast<VertexAttachment *>(baseAttachment);

				bool weighted = attachment->_bones.size() != 0;
				Vector<float> &verts = attachment->_vertices;
				int deformLength = weighted ? verts.size() / 3 * 2 : verts.size();

				DeformTimeline *timeline = new (__FILE__, __LINE__) DeformTimeline(timelineMap->_size,
																				   timelineMap->_size, slotIndex,
																				   attachment);
				float time = Json::getFloat(keyMap, ""time"", 0);
				for (frame = 0, bezier = 0;; frame++) {
					Json *vertices = Json::getItem(keyMap, ""vertices"");
					Vector<float> deformed;
					if (!vertices) {
						if (weighted) {
							deformed.setSize(deformLength, 0);
						} else {
							deformed.clearAndAddAll(attachment->_vertices);
						}
					} else {
						int v, start = Json::getInt(keyMap, ""offset"", 0);
						Json *vertex;
						deformed.setSize(deformLength, 0);
						if (_scale == 1) {
							for (vertex = vertices->_child, v = start; vertex; vertex = vertex->_next, ++v) {
								deformed[v] = vertex->_valueFloat;
							}
						} else {
							for (vertex = vertices->_child, v = start; vertex; vertex = vertex->_next, ++v) {
								deformed[v] = vertex->_valueFloat * _scale;
							}
						}
						if (!weighted) {
							Vector<float> &verticesAttachment = attachment->_vertices;
							for (v = 0; v < deformLength; ++v) {
								deformed[v] += verticesAttachment[v];
							}
						}
					}
					timeline->setFrame(frame, time, deformed);
					nextMap = keyMap->_next;
					if (!nextMap) {
						// timeline.shrink(); // BOZO
						break;
					}
					float time2 = Json::getFloat(nextMap, ""time"", 0);
					curve = Json::getItem(keyMap, ""curve"");
					if (curve) {
						bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, 0, 1, 1);
					}
					time = time2;
					keyMap = nextMap;
				}
				timelines.add(timeline);
			}
		}
	}

	/** Draw order timeline. */
	if (drawOrder) {
		DrawOrderTimeline *timeline = new (__FILE__, __LINE__) DrawOrderTimeline(drawOrder->_size);

		for (keyMap = drawOrder->_child, frame = 0; keyMap; keyMap = keyMap->_next, ++frame) {
			int ii;
			Vector<int> drawOrder2;
			Json *offsets = Json::getItem(keyMap, ""offsets"");
			if (offsets) {
				Json *offsetMap;
				Vector<int> unchanged;
				unchanged.ensureCapacity(skeletonData->_slots.size() - offsets->_size);
				unchanged.setSize(skeletonData->_slots.size() - offsets->_size, 0);
				size_t originalIndex = 0, unchangedIndex = 0;

				drawOrder2.ensureCapacity(skeletonData->_slots.size());
				drawOrder2.setSize(skeletonData->_slots.size(), 0);
				for (ii = (int) skeletonData->_slots.size() - 1; ii >= 0; --ii)
					drawOrder2[ii] = -1;

				for (offsetMap = offsets->_child; offsetMap; offsetMap = offsetMap->_next) {
					int slotIndex = findSlotIndex(skeletonData, Json::getString(offsetMap, ""slot"", 0), timelines);
					if (slotIndex == -1) return NULL;

					/* Collect unchanged items. */
					while (originalIndex != (size_t) slotIndex)
						unchanged[unchangedIndex++] = originalIndex++;
					/* Set changed items. */
					drawOrder2[originalIndex + Json::getInt(offsetMap, ""offset"", 0)] = originalIndex;
					originalIndex++;
				}
				/* Collect remaining unchanged items. */
				while (originalIndex < skeletonData->_slots.size())
					unchanged[unchangedIndex++] = originalIndex++;
				/* Fill in unchanged items. */
				for (ii = (int) skeletonData->_slots.size() - 1; ii >= 0; ii--)
					if (drawOrder2[ii] == -1) drawOrder2[ii] = unchanged[--unchangedIndex];
			}
			timeline->setFrame(frame, Json::getFloat(keyMap, ""time"", 0), drawOrder2);
		}
		timelines.add(timeline);
	}

	/** Event timeline. */
	if (events) {
		EventTimeline *timeline = new (__FILE__, __LINE__) EventTimeline(events->_size);

		for (keyMap = events->_child, frame = 0; keyMap; keyMap = keyMap->_next, ++frame) {
			Event *event;
			EventData *eventData = skeletonData->findEvent(Json::getString(keyMap, ""name"", 0));
			if (!eventData) {
				ContainerUtil::cleanUpVectorOfPointers(timelines);
				setError(NULL, ""Event not found: "", Json::getString(keyMap, ""name"", 0));
				return NULL;
			}

			event = new (__FILE__, __LINE__) Event(Json::getFloat(keyMap, ""time"", 0), *eventData);
			event->_intValue = Json::getInt(keyMap, ""int"", eventData->_intValue);
			event->_floatValue = Json::getFloat(keyMap, ""float"", eventData->_floatValue);
			event->_stringValue = Json::getString(keyMap, ""string"", eventData->_stringValue.buffer());
			if (!eventData->_audioPath.isEmpty()) {
				event->_volume = Json::getFloat(keyMap, ""volume"", 1);
				event->_balance = Json::getFloat(keyMap, ""balance"", 0);
			}
			timeline->setFrame(frame, event);
		}
		timelines.add(timeline);
	}

	float duration = 0;
	for (size_t i = 0; i < timelines.size(); i++)
		duration = MathUtil::max(duration, timelines[i]->getDuration());
	return new (__FILE__, __LINE__) Animation(String(root->_name), timelines, duration);
}

void SkeletonJson::readVertices(Json *attachmentMap, VertexAttachment *attachment, size_t verticesLength) {
	Json *entry;
	size_t i, n, nn, entrySize;
	Vector<float> vertices;

	attachment->setWorldVerticesLength(verticesLength);

	entry = Json::getItem(attachmentMap, ""vertices"");
	entrySize = entry->_size;
	vertices.ensureCapacity(entrySize);
	vertices.setSize(entrySize, 0);
	for (entry = entry->_child, i = 0; entry; entry = entry->_next, ++i)
		vertices[i] = entry->_valueFloat;

	if (verticesLength == entrySize) {
		if (_scale != 1) {
			for (i = 0; i < entrySize; ++i)
				vertices[i] *= _scale;
		}

		attachment->getVertices().clearAndAddAll(vertices);
		return;
	}

	Vertices bonesAndWeights;
	bonesAndWeights._bones.ensureCapacity(verticesLength * 3);
	bonesAndWeights._vertices.ensureCapacity(verticesLength * 3 * 3);

	for (i = 0, n = entrySize; i < n;) {
		int boneCount = (int) vertices[i++];
		bonesAndWeights._bones.add(boneCount);
		for (nn = i + boneCount * 4; i < nn; i += 4) {
			bonesAndWeights._bones.add((int) vertices[i]);
			bonesAndWeights._vertices.add(vertices[i + 1] * _scale);
			bonesAndWeights._vertices.add(vertices[i + 2] * _scale);
			bonesAndWeights._vertices.add(vertices[i + 3]);
		}
	}

	attachment->getVertices().clearAndAddAll(bonesAndWeights._vertices);
	attachment->getBones().clearAndAddAll(bonesAndWeights._bones);
}

void SkeletonJson::setError(Json *root, const String &value1, const String &value2) {
	_error = String(value1).append(value2);
	delete root;
}
",16255,True,3080.7751964080458,median
"[[intro_chapter]]
== Ethereum Basics

(((""Ethereum (generally)"",""basics"", id=""ix_02intro-asciidoc0"", range=""startofrange"")))In this chapter we will start exploring Ethereum, learning how to use wallets, how to create transactions, and also how to run a basic smart contract.

[[ether_units]]
=== Ether Currency Units

(((""currency units"")))(((""Ethereum (generally)"",""currency units"")))Ethereum's currency unit is called _ether_, identified also as ""ETH"" or with the symbols &#926; (from the Greek letter ""Xi"" that looks like a stylized capital E) or, less often, &#9830;: for example, 1 ether, or 1 ETH, or &#926;1, or &#9830;1.

[TIP]
====
Use Unicode character +U+039E+ for &#926; and +U+2666+ for &#9830;.
====

Ether is subdivided into smaller units, down to the smallest unit possible, which is named _wei_. One ether is 1 quintillion wei (1 * 10^18^ or 1,000,000,000,000,000,000). You may hear people refer to the currency ""Ethereum"" too, but this is a common beginner's mistake. Ethereum is the system, ether is the currency.

The value of ether is always represented internally in Ethereum as an unsigned integer value denominated in wei. When you transact 1 ether, the transaction encodes 1000000000000000000 wei as the value.

Ether's various denominations have both a _scientific name_ using the International System of Units (_SI_) and a colloquial name that pays homage to many of the great minds of computing and cryptography.

<<ether_denominations>> shows the various units, their colloquial (common) names, and their SI names. In keeping with the internal representation of value, the table shows all denominations in wei (first row), with ether shown as 10^18^ wei in the 7th row.

[[ether_denominations]]
.Ether denominations and unit names
[options=""header""]
|===
| Value (in wei) | Exponent | Common name | SI name
| 1 | 1 | wei | Wei
| 1,000 | 10^3^ | Babbage | Kilowei or femtoether
| 1,000,000 | 10^6^ | Lovelace | Megawei or picoether
| 1,000,000,000 | 10^9^ | Shannon | Gigawei or nanoether
| 1,000,000,000,000 | 10^12^ | Szabo | Microether or micro
| 1,000,000,000,000,000 | 10^15^ | Finney | Milliether or milli
| _1,000,000,000,000,000,000_ | _10^18^_ | _Ether_ | _Ether_
| 1,000,000,000,000,000,000,000 | 10^21^ | Grand | Kiloether
| 1,000,000,000,000,000,000,000,000 | 10^24^ | | Megaether
|===

[[choosing_eth_wallet]]
=== Choosing an Ethereum Wallet

(((""Ethereum (generally)"",""wallet choices"")))(((""wallets"",""choosing"")))(((""wallets"",""defined"")))The term ""wallet"" has come to mean many things, although they are all related and on a day-to-day basis boil down to pretty much the same thing. We will use the term ""wallet"" to mean a software application that helps you manage your Ethereum account. In short, an Ethereum wallet is your gateway to the Ethereum system. It holds your keys and can create and broadcast transactions on your behalf. Choosing an Ethereum wallet can be difficult because there are many different options with different features and designs. Some are more suitable for beginners and some are more suitable for experts. The Ethereum platform itself is still being improved, and the ""best"" wallets are often the ones that adapt to the changes that come with the platform upgrades.

But don't worry! If you choose a wallet and don't like how it works&#x2014;or if you like it at first but later want to try something else&#x2014;you can change wallets quite easily. All you have to do is make a transaction that sends your funds from the old wallet to the new wallet, or export your private keys and import them into the new one.

We've selected a few different types of wallets to use as examples throughout the book. Some are for mobile, desktop, and others are web-based. We've chosen different wallets because they represent a broad range of complexity and features. However, the selection of these wallets is not an endorsement of their quality or security. They are simply a good starting place for demonstrations and testing.

(((""private keys"",""wallets and"")))Remember that for a wallet application to work, it must have access to your private keys, so it is vital that you only download and use wallet applications from sources you trust. Fortunately, in general, the more popular a wallet application is, the more trustworthy it is likely to be. Nevertheless, it is good practice to avoid ""putting all your eggs in one basket"" and have your Ethereum accounts spread across a couple of wallets.

The following are some good starter wallets:

MetaMask:: (((""MetaMask"")))MetaMask is a browser extension wallet that runs in your browser (Chrome, Firefox, Opera, or Brave Browser). It is easy to use and convenient for testing, as it is able to connect to a variety of Ethereum nodes and test blockchains. MetaMask is a web-based wallet that also includes mobile apps for both iOS and Android.

Jaxx:: (((""Jaxx"")))(((""wallets"",""Jaxx"")))Jaxx is a multiplatform and multicurrency wallet that runs on a variety of operating systems, including Android, iOS, Windows, macOS, and Linux. It is often a good choice for new users as it is designed for simplicity and ease of use. Jaxx is either a mobile or a desktop wallet, depending on where you install it.

MyEtherWallet (MEW):: (((""MyEtherWallet (MEW)"")))(((""wallets"",""MyEtherWallet"")))MyEtherWallet is primarily a web-based wallet that runs in any browser. It is also available on Android and iOS. It has multiple sophisticated features we will explore in many of our examples.

Emerald Wallet:: (((""Ethereum Classic (ETC)"",""Emerald Wallet and"")))(((""wallets"",""Emerald Wallet"")))(((""Emerald Wallet"")))Emerald Wallet is designed to work with the Ethereum Classic blockchain, but is compatible with other Ethereum-based blockchains. It's an open source desktop application and works under Windows, macOS, and Linux. Emerald Wallet can run a full node or connect to a public remote node, working in a ""light"" mode. It also has a companion tool to do all operations from the command line.

We'll start by installing MetaMask on a desktop&#x2014;but first, we'll briefly discuss controlling and managing keys.

[[control_responsibility]]
=== Control and Responsibility

(((""Ethereum (generally)"",""control and responsibility"", id=""ix_02intro-asciidoc1"", range=""startofrange"")))Open blockchains like Ethereum are important because they operate as a _decentralized_ system. That means lots of things, but one crucial aspect is that each user of Ethereum can&#x2014;and should&#x2014;control their own private keys, which are the things that control access to funds and smart contracts. We sometimes call the combination of access to funds and smart contracts an ""account"" or ""wallet."" These terms can get quite complex in their functionality, so we will go into this in more detail later. As a fundamental principle, however, it is as easy as one private key equals one ""account."" Some users choose to give up control over their private keys by using a third-party custodian, such as an online exchange. In this book, we will teach you how to take control and manage your own private keys.

With control comes a big responsibility. If you lose your private keys, you lose access to your funds and contracts. No one can help you regain access&#x2014;your funds will be locked forever. Here are a few tips to help you manage this responsibility:

* Do not improvise security. Use tried-and-tested standard approaches.

* The more important the account (e.g., the higher the value of the funds controlled, or the more significant the smart contracts accessible), the higher security measures should be taken.

* The highest security is gained from an air-gapped device, but this level is not required for every account.

* Never store your private key in plain form, especially digitally. Fortunately, most user interfaces today won't even let you see the raw private key.

* (((""private keys"",""wallets and"")))Private keys can be stored in an encrypted form, as a digital ""keystore"" file. Being encrypted, they need a password to unlock. When you are prompted to choose a password, make it strong (i.e., long and random), back it up, and don't share it. If you don't have a password manager, write it down and store it in a safe and secret place. To access your account, you need both the keystore file and the password.

* Do not store any passwords in digital documents, digital photos, screenshots, online drives, encrypted PDFs, etc. Again, do not improvise security. Use a password manager or pen and paper.

* When you are prompted to back up a key as a mnemonic word sequence, use pen and paper to make a physical backup. Do not leave that task ""for later""; you will forget. These backups can be used to rebuild your private key in case you lose all the data saved on your system, or if you forget or lose your password. However, they can also be used by attackers to get your private keys, so never store them digitally, and keep the physical copy stored securely in a locked drawer or safe.

* Before transferring any large amounts (especially to new addresses), first do a small test transaction (e.g., less than $1 value) and wait for confirmation of receipt.

* When you create a new account, start by sending only a small test transaction to the new address. Once you receive the test transaction, try sending back again from that account. There are lots of reasons account creation can go wrong, and if it has gone wrong, it is better to find out with a small loss. If the tests work, all is well.

* Public block explorers are an easy way to independently see whether a transaction has been accepted by the network. However, this convenience has a negative impact on your privacy, because you reveal your addresses to block explorers, which can track you.

* Do not send money to any of the addresses shown in this book. The private keys are listed in the book and someone will immediately take that money.

Now that we've covered some basic best practices for key management and security, let's get to work using MetaMask!(((range=""endofrange"", startref=""ix_02intro-asciidoc1"")))

[[installing_MetaMask]]
=== Getting Started with MetaMask

(((""Ethereum (generally)"",""MetaMask basics"", id=""ix_02intro-asciidoc2"", range=""startofrange"")))(((""MetaMask"",""basics"", id=""ix_02intro-asciidoc3"", range=""startofrange"")))Open the Google Chrome browser and navigate to https://chrome.google.com/webstore/category/extensions[].

Search for ""MetaMask"" and click on the logo of a fox. You should see something like the result shown in <<metamask_download>>.

[[metamask_download]]
.The detail page of the MetaMask Chrome extension
image::images/metamask_download.png[""MetaMask Detail Page""]

It's important to verify that you are downloading the real MetaMask extension, as sometimes people are able to sneak malicious extensions past Google's filters. The real one:

* Shows the ID +nkbihfbeogaeaoehlefnkodbefgpgknn+ in the address bar
* Is offered by https://metamask.io
* Has more than 1,500 reviews
* Has more than 1,000,000 users

Once you confirm you are looking at the correct extension, click ""Add to Chrome"" to install it.

[[using_MetaMask]]
==== Creating a Wallet

(((""MetaMask"",""wallet setup with"", id=""ix_02intro-asciidoc4"", range=""startofrange"")))Once MetaMask is installed you should see a new icon (the head of a fox) in your browser's toolbar. Click on it to get started. You will be asked to accept the terms and conditions and then to create your new Ethereum wallet by entering a password (see <<metamask_password>>).

[[metamask_password]]
.The password page of the MetaMask Chrome extension
image::images/metamask_password.png[""MetaMask Password Page""]

[TIP]
====
The password controls access to MetaMask, so that it can't be used by anyone with access to your browser.
====

(((""mnemonic code words"",""MetaMask and"", id=""ix_02intro-asciidoc5"", range=""startofrange"")))Once you've set a password, MetaMask will generate a wallet for you and show you a _mnemonic backup_ consisting of 12 English words (see <<metamask_mnemonic>>). These words can be used in any compatible wallet to recover access to your funds should something happen to MetaMask or your computer. You do not need the password for this recovery; the 12 words are sufficient.

[TIP]
====
Back up your mnemonic (12 words) on paper, twice. Store the two paper backups in two separate secure locations, such as a fire-resistant safe, a locked drawer, or a safe deposit box. Treat the paper backups like cash of equivalent value to what you store in your Ethereum wallet. Anyone with access to these words can gain access and steal your money.
====

[[metamask_mnemonic]]
.The mnemonic backup of your wallet, created by MetaMask
image::images/metamask_mnemonic.png[""MetaMask Mnemonic Page""]

Once you have confirmed that you have stored the mnemonic securely, you'll be able to see the details of your Ethereum account, as shown in <<metamask_account>>.(((range=""endofrange"", startref=""ix_02intro-asciidoc5"")))

[[metamask_account]]
.Your Ethereum account in MetaMask
image::images/metamask_account.png[""MetaMask Account Page""]

Your account page shows the name of your account (""Account 1"" by default), an Ethereum address (+0x9E713...+ in the example), and a colorful icon to help you visually distinguish this account from other accounts. At the top of the account page, you can see which Ethereum network you are currently working on (""Main Network"" in the example).

Congratulations! You have set up your first Ethereum wallet.(((range=""endofrange"", startref=""ix_02intro-asciidoc4"")))

[[switching_networks]]
==== Switching Networks

(((""MetaMask"",""network choices"")))As you can see on the MetaMask account page, you can choose between multiple Ethereum networks. By default, MetaMask will try to connect to the main network. The other choices are public testnets, any Ethereum node of your choice, or nodes running private blockchains on your own computer (localhost):

Main Ethereum Network:: The main public Ethereum blockchain. Real ETH, real value, and real consequences.

Ropsten Test Network:: Ethereum public test blockchain and network. ETH on this network has no value.

Kovan Test Network:: Ethereum public test blockchain and network using the Aura consensus protocol with proof of authority (federated signing). ETH on this network has no value. The Kovan test network is supported by Parity only. Other Ethereum clients use the Clique consensus protocol, which was proposed later, for proof of authority&#x2013;based verification.

Rinkeby Test Network:: Ethereum public test blockchain and network, using the Clique consensus protocol with proof of authority (federated signing). ETH on this network has no value.

Localhost 8545:: Connects to a node running on the same computer as the browser. The node can be part of any public blockchain (main or testnet), or a private testnet.

Custom RPC:: Allows you to connect MetaMask to any node with a Geth-compatible Remote Procedure Call (RPC) interface. The node can be part of any public or private blockchain.

[NOTE]
====
Your MetaMask wallet uses the same private key and Ethereum address on all the networks it connects to. However, your Ethereum address balance on each Ethereum network will be different. Your keys may control ether and contracts on Ropsten, for example, but not on the main network.
====

[[getting_test_eth]]
==== Getting Some Test Ether

(((""ether (generally)"",""testnet"")))(((""MetaMask"",""and testnet ether"")))(((""test ether"",""obtaining"")))(((""testnet"",""ether for"")))(((""wallets"",""testnet ether and"")))Your first task is to get your wallet funded. You won't be doing that on the main network because real ether costs money and handling it requires a bit more experience. For now, you'll load your wallet with some testnet ether.

(((""Ropsten Test Network"")))Switch MetaMask to the _Ropsten Test Network_. Click Deposit, then click Ropsten Test Faucet. MetaMask will open a new web page, as shown in <<metamask_ropsten_faucet>>.

[[metamask_ropsten_faucet]]
.MetaMask Ropsten Test Faucet
image::images/metamask_ropsten_faucet.png[""MetaMask Ropsten Test Faucet""]

You may notice that the web page already contains your MetaMask wallet's Ethereum address. MetaMask integrates Ethereum-enabled web pages with your MetaMask wallet and can ""see"" Ethereum addresses on the web page, allowing you, for example, to send a payment to an online shop displaying an Ethereum address. MetaMask can also populate the web page with your own wallet's address as a recipient address if the web page requests it. In this page, the faucet application is asking MetaMask for a wallet address to send test ether to.

Click the green ""request 1 ether from faucet"" button. You will see a transaction ID appear in the lower part of the page. The faucet app has created a transaction&#x2014;a payment to you. The transaction ID looks like this:

[[faucet_tx_id]]
----
0x7c7ad5aaea6474adccf6f5c5d6abed11b70a350fbc6f9590109e099568090c57
----

In a few seconds, the new transaction will be mined by the Ropsten miners and your MetaMask wallet will show a balance of 1 ETH. Click on the transaction ID and your browser will take you to a _block explorer_, which is a website that allows you to visualize and explore blocks, addresses, and transactions. MetaMask uses the https://etherscan.io/[Etherscan block explorer], one of the more popular Ethereum block explorers. The transaction containing the payment from the Ropsten Test Faucet is shown in <<ropsten_block_explorer>>.

[[ropsten_block_explorer]]
.Etherscan Ropsten block explorer
image::images/ropsten_block_explorer.png[""Etherscan Ropsten Block Explorer""]

The transaction has been recorded on the Ropsten blockchain and can be viewed at any time by anyone, simply by searching for the transaction ID, or http://bit.ly/2Q860Wk[visiting the link].

Try visiting that link, or entering the transaction hash into the _ropsten.etherscan.io_ website, to see it for yourself.

[[sending_eth_MetaMask]]
==== Sending Ether from MetaMask

(((""MetaMask"",""sending ether from"", id=""ix_02intro-asciidoc6"", range=""startofrange"")))(((""test ether"",""sending"", id=""ix_02intro-asciidoc7"", range=""startofrange"")))Once you've received your first test ether from the Ropsten Test Faucet, you can experiment with sending ether by trying to send some back to the faucet. As you can see on the Ropsten Test Faucet page, there is an option to ""donate"" 1 ETH to the faucet. This option is available so that once you're done testing, you can return the remainder of your test ether, so that someone else can use it next. Even though test ether has no value, some people hoard it, making it difficult for everyone else to use the test networks. Hoarding test ether is frowned upon!

Fortunately, we are not test ether hoarders. Click the orange ""1 ether"" button to tell MetaMask to create a transaction paying the faucet 1 ether. MetaMask will prepare a transaction and pop up a window with the confirmation, as shown in <<send_to_faucet>>.


[[send_to_faucet]]
.Sending 1 ether to the faucet
image::images/send_to_faucet.png[""Sending 1 ether to the faucet""]

Oops! You probably noticed you can't complete the transaction&#x2014;MetaMask says you have an insufficient balance. At first glance this may seem confusing: you have 1 ETH, you want to send 1 ETH, so why is MetaMask saying you have insufficient funds?

(((""gas"",""basics"")))The answer is because of the cost of _gas_. Every Ethereum transaction requires payment of a fee, which is collected by the miners to validate the transaction. The fees in Ethereum are charged in a virtual currency called gas. You pay for the gas with ether, as part of the transaction.

[NOTE]
====
(((""gas"",""on test networks"")))Fees are required on the test networks too. Without fees, a test network would behave differently from the main network, making it an inadequate testing platform. Fees also protect the test networks from DoS attacks and poorly constructed contracts (e.g., infinite loops), much like they protect the main network.
====

When you sent the transaction, MetaMask calculated the average gas price of recent successful transactions at 3 gwei, which stands for gigawei. Wei is the smallest pass:[<span class=""keep-together"">subdivision</span>] of the ether currency, as we discussed in <<ether_units>>. The gas limit is set at the cost of sending a basic transaction, which is 21,000 gas units. Therefore, the maximum amount of ETH you will spend is 3 * 21,000 gwei = 63,000 gwei = 0.000063 ETH. (Be advised that average gas prices can fluctuate, as they are predominantly determined by miners. We will see in a later chapter how you can increase/decrease your gas limit to ensure your transaction takes precedence if need be.)

All this to say: making a 1 ETH transaction costs 1.000063 ETH. MetaMask confusingly rounds that _down_ to 1 ETH when showing the total, but the actual amount you need is 1.000063 ETH and you only have 1 ETH. Click Reject to cancel this transaction.

Let's get some more test ether! Click the green ""request 1 ether from the faucet"" button again and wait a few seconds. Don't worry, the faucet should have plenty of ether and will give you more if you ask.

Once you have a balance of 2 ETH, you can try again. This time, when you click the orange ""1 ether"" donation button, you have sufficient balance to complete the transaction. Click Submit when MetaMask pops up the payment window. After all of this, you should see a balance of 0.999937 ETH because you sent 1 ETH to the faucet with 0.000063 ETH in gas.(((range=""endofrange"", startref=""ix_02intro-asciidoc7"")))(((range=""endofrange"", startref=""ix_02intro-asciidoc6"")))

[[explore_tx_history]]
==== Exploring the Transaction History of an Address

(((""addresses"",""exploring transaction history of"", id=""ix_02intro-asciidoc8"", range=""startofrange"")))(((""MetaMask"",""exploring transaction history of an address with"", id=""ix_02intro-asciidoc9"", range=""startofrange"")))By now you have become an expert in using MetaMask to send and receive test ether. Your wallet has received at least two payments and sent at least one. You can view all these transactions using the _ropsten.etherscan.io_ block explorer. You can either copy your wallet address and paste it into the block explorer's search box, or have MetaMask open the page for you. Next to your account icon in MetaMask, you will see a button showing three dots. Click on it to show a menu of account-related options (see <<metamask_account_context_menu>>).

[[metamask_account_context_menu]]
.MetaMask account context menu
image::images/metamask_account_context_menu.png[""MetaMask Account Context Menu""]

Select ""View account on Etherscan"" to open a web page in the block explorer showing your account's transaction history, as shown in <<block_explorer_account_history>>.

[[block_explorer_account_history]]
.Address transaction history on Etherscan
image::images/block_explorer_account_history.png[""Address Transaction History on Etherscan""]

Here you can see the entire transaction history of your Ethereum address. It shows all the transactions recorded on the Ropsten blockchain where your address is the sender or recipient. Click on a few of these transactions to see more details.

You can explore the transaction history of any address. Take a look at the transaction history of the Ropsten Test Faucet address (hint: it is the ""sender"" address listed in the oldest payment to your address). You can see all the test ether sent from the faucet to you and to other addresses. Every transaction you see can lead you to more addresses and more transactions. Before long you will be lost in the maze of interconnected data. Public blockchains contain an enormous wealth of information, all of which can be explored programmatically, as we will see in future examples(((range=""endofrange"", startref=""ix_02intro-asciidoc9"")))(((range=""endofrange"", startref=""ix_02intro-asciidoc8""))).(((range=""endofrange"", startref=""ix_02intro-asciidoc3"")))(((range=""endofrange"", startref=""ix_02intro-asciidoc2"")))

[[intro_world_computer]]
=== Introducing the World Computer

(((""Ethereum (generally)"",""and EVM"")))(((""EVM (Ethereum Virtual Machine)"",""as world computer"")))(((""world computer, Ethereum as"")))You've now created a wallet and sent and received ether. So far, we've treated Ethereum as a cryptocurrency. But Ethereum is much, much more. In fact, the cryptocurrency function is subservient to Ethereum's function as a decentralized world computer. (((""smart contracts"",""ether and"")))Ether is meant to be used to pay for running _smart contracts_, which are computer programs that run on an emulated computer called the _Ethereum Virtual Machine_ (EVM).

The EVM is a global singleton, meaning that it operates as if it were a global, single-instance computer, running everywhere. Each node on the Ethereum network runs a local copy of the EVM to validate contract execution, while the Ethereum blockchain records the changing _state_ of this world computer as it processes transactions and smart contracts. We'll discuss this in much greater detail in <<evm_chapter>>.

[[EOA_contracts]]
=== Externally Owned Accounts (EOAs) and Contracts

(((""contract accounts"", seealso=""smart contracts"")))(((""EOA (Externally Owned Account)"",""basics"")))(((""Ethereum (generally)"",""EOAs and contracts"")))(((""smart contracts"",""basics"")))The type of account you created in the MetaMask wallet is called an _externally owned account_ (EOA). Externally owned accounts are those that have a private key; having the private key means control over access to funds or contracts. Now, you're probably guessing there is another type of account. That other type of account is a _contract account_. A contract account has smart contract code, which a simple EOA can't have. Furthermore, a contract account does not have a private key. Instead, it is owned (and controlled) by the logic of its smart contract code: the software program recorded on the Ethereum blockchain at the contract account's creation and executed by the EVM.

Contracts have addresses, just like EOAs. Contracts can also send and receive ether, just like EOAs. However, when a transaction destination is a contract address, it causes that contract to _run_ in the EVM, using the transaction, and the transaction's data, as its input. In addition to ether, transactions can contain _data_ indicating which specific function in the contract to run and what parameters to pass to that function. In this way, transactions can _call_ functions within contracts.

Note that because a contract account does not have a private key, it cannot _initiate_ a transaction. Only EOAs can initiate transactions, but contracts can _react_ to transactions by calling other contracts, building complex execution paths. One typical use of this is an EOA sending a request transaction to a multisignature smart contract wallet to send some ETH on to another address. A typical DApp programming pattern is to have Contract A calling Contract B in order to maintain a shared state across users of Contract A.

In the next few sections, we will write our first contract. You will then learn how to create, fund, and use that contract with your MetaMask wallet and test ether on the Ropsten test network.

[[simple_contract_example]]
=== A Simple Contract: A Test Ether Faucet

(((""contract accounts"",""creating"", seealso=""Faucet.sol contract"", id=""ix_02intro-asciidoc10"", range=""startofrange"")))(((""Faucet.sol contract (test example)"",""creating"", id=""ix_02intro-asciidoc11"", range=""startofrange"")))Ethereum has many different high-level languages, all of which can be used to write a contract and produce EVM bytecode. You can read about many of the most prominent and interesting ones in <<high_level_languages>>. One high-level language is by far the dominant choice for smart contract programming: Solidity. (((""Wood, Dr. Gavin"",""and Solidity"")))Solidity was created by Dr. Gavin Wood, the coauthor of this book, and has become the most widely used language in Ethereum (and beyond). We'll use Solidity to write our first contract.

(((""Solidity"",""faucet.sol and"")))For our first example (<<solidity_faucet_example>>), we will write a contract that controls a _faucet_. You've already used a faucet to get test ether on the Ropsten test network. A faucet is a relatively simple thing: it gives out ether to any address that asks, and can be refilled periodically. You can implement a faucet as a wallet controlled by a human or a web server.

[[solidity_faucet_example]]
.Faucet.sol: A Solidity contract implementing a faucet
====
[source,solidity,linenums]
----
include::code/Solidity/Faucet.sol[]
----
====

[NOTE]
====
You will find all the code samples for this book in the _code_ subdirectory of https://github.com/ethereumbook/ethereumbook/[the book's GitHub repository]. Specifically, our _Faucet.sol_ contract is in:

----
code/Solidity/Faucet.sol
----
====

This is a very simple contract, about as simple as we can make it. It is also a _flawed_ contract, demonstrating a number of bad practices and security vulnerabilities. We will learn by examining all of its flaws in later sections. But for now, let's look at what this contract does and how it works, line by line. You will quickly notice that many elements of Solidity are similar to existing programming languages, such as JavaScript, Java, or Cpass:[++].

The first line is a comment:

[[comment]]
[source,solidity]
----
// SPDX-License-Identifier: CC-BY-SA-4.0
----

Comments are for humans to read and are not included in the executable EVM bytecode. We usually put them on the line before the code we are trying to explain, or sometimes on the same line. Comments start with two forward slashes: +//+. Everything from the first slash until the end of that line is treated the same as a blank line and ignored.

A few lines later is where our actual contract starts:

[[contract_definition]]
[source,solidity]
----
contract Faucet {
----

This line declares a +contract+ object, similar to a +class+ declaration in other object-oriented languages. The contract definition includes all the lines between the curly braces (pass:[<code>{}</code>]), which define a _scope_, much like how curly braces are used in many other programming languages.

Next, we enable the contract to accept any incoming amount:

[[receive_function]]
[source,solidity]
----
receive () external payable {}
----

(((""receive function"")))The receive function is called if the transaction that triggered the contract didn't name any of the declared functions in the contract, or didn't contain data and thus was a plain Ether transfer. Contracts can have one such receive function (without a name) and it is used to receive ether. That's why it is defined as an external and payable function, which means it can accept ether into the contract. It doesn't do anything, other than accept the ether, as indicated by the empty definition in the curly braces pass:[(<code>{}</code>)]. If we make a transaction that sends ether to the contract address, as if it were a wallet, this function will handle it.

After this, we declare the first function of the +Faucet+ contract:

[[withdraw_function]]
[source,solidity]
----
function withdraw(uint withdraw_amount) public {
----

The function is named +withdraw+, and it takes one unsigned integer (+uint+) argument named +withdraw_amount+. It is declared as a public function, meaning it can be called by other contracts. The function definition follows, between curly braces. The first part of the +withdraw+ function sets a limit on withdrawals:

[[withdraw_limit]]
[source,solidity]
----
require(withdraw_amount <= 100000000000000000);
----

It uses the built-in Solidity function +require+ to test a precondition, that the +withdraw_amount+ is less than or equal to 100,000,000,000,000,000 wei, which is the base unit of ether (see <<ether_denominations>>) and equivalent to 0.1 ether. If the +withdraw+ function is called with a +withdraw_amount+ greater than that amount, the +require+ function here will cause contract execution to stop and fail with an _exception_. Note that statements need to be terminated with a semicolon in Solidity.

This part of the contract is the main logic of our faucet. It controls the flow of funds out of the contract by placing a limit on withdrawals. It's a very simple control but can give you a glimpse of the power of a programmable blockchain: decentralized software controlling money.

Next comes the actual withdrawal:

[[withdraw_command]]
[source,solidity]
----
msg.sender.transfer(withdraw_amount);
----

A couple of interesting things are happening here. The +msg+ object is one of the inputs that all contracts can access. It represents the transaction that triggered the execution of this contract. The attribute +sender+ is the sender address of the transaction. The function +transfer+ is a built-in function that transfers ether from the current contract to the address of the sender. Reading it backward, this means +transfer+ to the +sender+ of the +msg+ that triggered this contract execution. The +transfer+ function takes an amount as its only argument. We pass the +withdraw_amount+ value that was the parameter to the +withdraw+ function declared a few lines earlier.

The very next line is the closing curly brace, indicating the end of the definition of our +withdraw+ function.

Right below our default function is the final closing curly brace, which closes the definition of the contract +Faucet+. That's it!(((range=""endofrange"", startref=""ix_02intro-asciidoc11"")))(((range=""endofrange"", startref=""ix_02intro-asciidoc10"")))

[[compile_faucet_contract]]
=== Compiling the Faucet Contract

(((""compiling"",""Faucet.sol contract"", id=""ix_02intro-asciidoc12"", range=""startofrange"")))(((""Faucet.sol contract (test example)"",""compiling"", id=""ix_02intro-asciidoc13"", range=""startofrange"")))Now that we have our first example contract, we need to use a Solidity compiler to convert the Solidity code into EVM bytecode so it can be executed by the EVM on the blockchain itself.

The Solidity compiler comes as a standalone executable, as part of various frameworks, and bundled in Integrated Development Environments (IDEs). To keep things simple, we will use one of the more popular IDEs, called _Remix_.

(((""Remix IDE"")))Use your Chrome browser (with the MetaMask wallet you installed earlier) to navigate to the Remix IDE at https://remix.ethereum.org[].

When you first load Remix, it will start with a sample contract called _ballot.sol_. We don't need that, so close it by clicking the +x+ on the corner of the tab, as seen in <<remix_close_tab>>.

[[remix_close_tab]]
.Close the default example tab
image::images/remix_close_tab.png[""Close the default example tab""]

Now, add a new tab by clicking on the circular plus sign in the top-left toolbar, as seen in <<remix_toolbar>>. Name the new file _Faucet.sol_.

[[remix_toolbar]]
.Click the plus sign to open a new tab
image::images/remix_toolbar.png[""Click the plus sign to open a new tab""]

Once you have the new tab open, copy and paste the code from our example _Faucet.sol_, as seen in <<remix_faucet_load>>.

[[remix_faucet_load]]
.Copy the Faucet example code into the new tab
image::images/remix_faucet_load.png[""Copy the Faucet example code into the new tab""]

Once you have loaded the _Faucet.sol_ contract into the Remix IDE, the IDE will automatically compile the code. If all goes well, you will see a green box with ""Faucet"" in it appear on the right, under the Compile tab, confirming the successful compilation (see <<remix_compile>>).

[[remix_compile]]
.Remix successfully compiles the Faucet.sol contract
image::images/remix_compile.png[""""]

If something goes wrong, the most likely problem is that the Remix IDE is using a version of the Solidity compiler that is different from 0.6. In that case, our pragma directive will prevent _Faucet.sol_ from compiling. To change the compiler version, go to the Settings tab, set the version to 0.6.0, and try again.

The Solidity compiler has now compiled our _Faucet.sol_ into EVM bytecode. If you are curious, the bytecode looks like this:

[[faucet_bytecode]]
----
PUSH1 0x80 PUSH1 0x40 MSTORE CALLVALUE DUP1 ISZERO PUSH2 0x10 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH1 0xF4 DUP1 PUSH2 0x1F PUSH1 0x0 CODECOPY PUSH1 0x0 RETURN INVALID PUSH1 0x80 PUSH1 0x40 MSTORE PUSH1 0x4 CALLDATASIZE LT PUSH1 0x1F JUMPI PUSH1 0x0 CALLDATALOAD PUSH1 0xE0 SHR DUP1 PUSH4 0x2E1A7D4D EQ PUSH1 0x2A JUMPI PUSH1 0x25 JUMP JUMPDEST CALLDATASIZE PUSH1 0x25 JUMPI STOP JUMPDEST PUSH1 0x0 DUP1 REVERT JUMPDEST CALLVALUE DUP1 ISZERO PUSH1 0x35 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST POP PUSH1 0x5F PUSH1 0x4 DUP1 CALLDATASIZE SUB PUSH1 0x20 DUP2 LT ISZERO PUSH1 0x4A JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST DUP2 ADD SWAP1 DUP1 DUP1 CALLDATALOAD SWAP1 PUSH1 0x20 ADD SWAP1 SWAP3 SWAP2 SWAP1 POP POP POP PUSH1 0x61 JUMP JUMPDEST STOP JUMPDEST PUSH8 0x16345785D8A0000 DUP2 GT ISZERO PUSH1 0x75 JUMPI PUSH1 0x0 DUP1 REVERT JUMPDEST CALLER PUSH20 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF AND PUSH2 0x8FC DUP3 SWAP1 DUP2 ISZERO MUL SWAP1 PUSH1 0x40 MLOAD PUSH1 0x0 PUSH1 0x40 MLOAD DUP1 DUP4 SUB DUP2 DUP6 DUP9 DUP9 CALL SWAP4 POP POP POP POP ISZERO DUP1 ISZERO PUSH1 0xBA JUMPI RETURNDATASIZE PUSH1 0x0 DUP1 RETURNDATACOPY RETURNDATASIZE PUSH1 0x0 REVERT JUMPDEST POP POP JUMP INVALID LOG2 PUSH5 0x6970667358 0x22 SLT KECCAK256 STOP CODECOPY 0xDC DUP16 0xD SGT PUSH6 0xD2245039EDD7 RETURN CALLDATALOAD 0xC2 0xE4 SWAP9 0xF6 0x2C 0xF8 0xB3 OR JUMPDEST 0xAC 0xD8 CREATE2 SSTORE 0x4E SIGNEXTEND PUSH4 0x3164736F PUSH13 0x634300060C0033000000000000
----

Aren't you glad you are using a high-level language like Solidity instead of programming directly in EVM bytecode? Me too!(((range=""endofrange"", startref=""ix_02intro-asciidoc13"")))(((range=""endofrange"", startref=""ix_02intro-asciidoc12"")))

[[create_contract]]
=== Creating the Contract on the Blockchain

(((""blockchain"",""creating contract on"", id=""ix_02intro-asciidoc14"", range=""startofrange"")))(((""Faucet.sol contract (test example)"",""on the blockchain"", id=""ix_02intro-asciidoc15"", range=""startofrange"")))So, we have a contract. We've compiled it into bytecode. Now, we need to ""register"" the contract on the Ethereum blockchain. We will be using the Ropsten testnet to test our contract, so that's the blockchain we want to submit it to.

(((""zero address"",""contract registration"")))Registering a contract on the blockchain involves creating a special transaction whose destination is the address +0x0000000000000000000000000000000000000000+, also known as the _zero address_. The zero address is a special address that tells the Ethereum blockchain that you want to register a contract. Fortunately, the Remix IDE will handle all of that for you and send the transaction to MetaMask.

(((""Remix IDE"", id=""ix_02intro-asciidoc16"", range=""startofrange"")))First, switch to the Run tab and select Injected Web3 in the Environment drop-down selection box. This connects the Remix IDE to the MetaMask wallet, and through MetaMask to the Ropsten test network. Once you do that, you can see Ropsten under Environment. Also, in the Account selection box it shows the address of your wallet (see <<remix_run>>).

[[remix_run]]
.Remix IDE Run tab, with Injected Web3 environment selected
image::images/remix_run.png[""Remix IDE Run tab, with Injected Web3 environment selected""]

Right below the Run settings you just confirmed is the +Faucet+ contract, ready to be created. Click on the Deploy button shown in <<remix_run>>.

Remix will construct the special ""creation"" transaction and MetaMask will ask you to approve it, as shown in <<remix_metamask_create>>. You'll notice the contract creation transaction has no ether in it, but it has 275 bytes of data (the compiled contract) and will consume 3 gwei in gas. Press Confirm to approve it.

[[remix_metamask_create]]
.MetaMask showing the contract creation transaction
image::images/remix_metamask_create.png[""MetaMask showing the contract creation transaction""]

Now you have to wait. It will take about 15 to 30 seconds for the contract to be mined on Ropsten. Remix won't appear to be doing much, but be patient.

Once the contract is created, it appears at the bottom of the Run tab (see <<remix_contract_interact>>).

[[remix_contract_interact]]
.The Faucet contract is ALIVE!
image::images/remix_contract_interact.png[""The Faucet contract is ALIVE!""]

Notice that the +Faucet+ contract now has an address of its own: Remix shows it as &#x201c;Faucet at 0x72e...c7829&#x201d; (although your address, the random letters and numbers, will be different). The small clipboard symbol to the right allows you to copy the contract address to your clipboard. We will use that in the next section.(((range=""endofrange"", startref=""ix_02intro-asciidoc16"")))(((range=""endofrange"", startref=""ix_02intro-asciidoc15"")))

[[interact_contract]]
=== Interacting with the Contract

(((""Faucet.sol contract (test example)"",""interacting with"", id=""ix_02intro-asciidoc17"", range=""startofrange"")))Let's recap what we've learned so far: Ethereum contracts are programs that control money, which run inside a virtual machine called the EVM. They are created by a special transaction that submits their bytecode to be recorded on the blockchain. Once they are created on the blockchain, they have an Ethereum address, just like wallets. Anytime someone sends a transaction to a contract address it causes the contract to run in the EVM, with the transaction as its input. Transactions sent to pass:[<span class=""keep-together"">contract</span>] addresses may have ether or data or both. If they contain ether, it is ""deposited"" to the contract balance. If they contain data, the data can specify a named function in the contract and call it, passing arguments to the function.

[[view_contract_address]]
==== Viewing the Contract Address in a Block Explorer

(((""Faucet.sol contract (test example)"",""viewing contract address in a block explorer"")))We now have a contract recorded on the blockchain, and we can see it has an Ethereum address. Let's check it out in the _ropsten.etherscan.io_ block explorer and see what a contract looks like. In the Remix IDE, copy the address of the contract by clicking the clipboard icon next to its name (see <<remix_contract_address>>).

[[remix_contract_address]]
.Copy the contract address from Remix
image::images/remix_contract_address.png[""Copy the contract address from Remix""]

Keep Remix open; we'll come back to it again later. Now, navigate your browser to _ropsten.etherscan.io_ and paste the address into the search box. You should see the contract's Ethereum address history, as shown in <<etherscan_contract_address>>.(((range=""endofrange"", startref=""ix_02intro-asciidoc17"")))

[[etherscan_contract_address]]
.View the Faucet contract address in the Etherscan block explorer
image::images/etherscan_contract_address.png[""View the Faucet contract address in the etherscan block explorer""]

[[fund_contract]]
==== Funding the Contract

(((""Faucet.sol contract (test example)"",""sending ether to"", id=""ix_02intro-asciidoc18"", range=""startofrange"")))For now, the contract only has one transaction in its history: the contract creation transaction. As you can see, the contract also has no ether (zero balance). That's because we didn't send any ether to the contract in the creation transaction, even though we could have.

Our faucet needs funds! Our first project will be to use MetaMask to send ether to the contract. You should still have the address of the contract in your clipboard (if not, copy it again from Remix). Open MetaMask, and send 1 ether to it, exactly as you would to any other Ethereum address (see <<metamask_send_to_contract>>).

[[metamask_send_to_contract]]
.Send 1 ether to the contract address
image::images/metamask_send_to_contract.png[""""]

In a minute, if you reload the Etherscan block explorer, it will show another transaction to the contract address and an updated balance of 1 ether.

Remember the unnamed default external payable function in our _Faucet.sol_ code? It looked like this:

[[receive_function_review]]
[source,solidity]
----
receive () external payable {}
----

When you sent a transaction to the contract address, with no data specifying which function to call, it called this default function. Because we declared it as +payable+, it accepted and deposited the 1 ether into the contract's account balance. Your transaction caused the contract to run in the EVM, updating its balance. You have funded your faucet!(((range=""endofrange"", startref=""ix_02intro-asciidoc18"")))

[[withdraw_from_contract]]
==== Withdrawing from Our Contract

(((""Faucet.sol contract (test example)"",""withdrawing funds from"", id=""ix_02intro-asciidoc19"", range=""startofrange"")))(((""withdrawal of funds from contract"", id=""ix_02intro-asciidoc20"", range=""startofrange"")))Next, let's withdraw some funds from the faucet. To withdraw, we have to construct a transaction that calls the +withdraw+ function and passes a +withdraw_amount+ argument to it. To keep things simple for now, Remix will construct that transaction for us and MetaMask will present it for our approval.

Return to the Remix tab and look at the contract on the Run tab. You should see a orange box labeled +withdraw+ with a field entry labeled +uint256 withdraw_amount+ (see <<remix_contract_withdraw>>).

[[remix_contract_withdraw]]
.The withdraw function of Faucet.sol, in Remix
image::images/remix_contract_interact.png[""The withdraw function of Faucet.sol, in Remix""]

This is the Remix interface to the contract. It allows us to construct transactions that call the functions defined in the contract. We will enter a +withdraw_amount+ and click the withdraw button to generate the transaction.

First, let's figure out the +withdraw_amount+. We want to try and withdraw 0.1 ether, which is the maximum amount allowed by our contract. Remember that all currency values in Ethereum are denominated in wei internally, and our +withdraw+ function expects the +withdraw_amount+ to be denominated in wei too. The amount we want is 0.1 ether, which is 100,000,000,000,000,000 wei (a 1 followed by 17 zeros).



[TIP]
====
Due to a limitation in JavaScript, a number as large as 10^17 cannot be processed by Remix. Instead, we enclose it in double quotes, to allow Remix to receive it as a string and manipulate it as a +BigNumber+. If we don't enclose it in quotes, the Remix IDE will fail to process it and display ""Error encoding arguments: Error: Assertion failed.""
====

Type ""100000000000000000"" (with the quotes) into the +withdraw_amount+ box and click on the withdraw button (see <<remix_withdraw>>).

[[remix_withdraw]]
.Click ""withdraw"" in Remix to create a withdrawal transaction
image::images/remix_withdraw.png[""""]

MetaMask will pop up a transaction window for you to approve. Click Confirm to send your withdrawal call to the contract (see <<metamask_withdraw>>).

[[metamask_withdraw]]
.MetaMask transaction to call the withdraw function
image::images/metamask_withdraw.png[""MetaMask transaction to call the withdraw function""]

Wait a minute and then reload the Etherscan block explorer to see the transaction reflected in the +Faucet+ contract address history (see <<etherscan_withdrawal_tx>>).

[[etherscan_withdrawal_tx]]
.Etherscan shows the transaction calling the withdraw function
image::images/etherscan_withdrawal_tx.png[""Etherscan shows the transaction calling the withdraw function""]


We now see a new transaction with the contract address as the destination and a value of 0 ether. The contract balance has changed and is now 0.9 ether because it sent us 0.1 ether as requested. But we don't see an ""OUT"" transaction in the _contract address history_.

Where's the outgoing withdrawal? A new tab has appeared on the contract's address history page, named Internal Transactions. (((""internal transaction (message)"")))Because the 0.1 ether transfer originated from the contract code, it is an internal transaction (also called a _message_). Click on that tab to see it (see <<etherscan_withdrawal_internal>>).


This ""internal transaction"" was sent by the contract in this line of code (from the pass:[<code><span class=""keep-together"">withdraw</span></code>] function in _Faucet.sol_):

[[withdraw_command_review]]
[source,solidity]
----
msg.sender.transfer(withdraw_amount);
----

To recap: you sent a transaction from your MetaMask wallet that contained data instructions to call the +withdraw+ function with a +withdraw_amount+ argument of 0.1 ether. That transaction caused the contract to run inside the EVM. As the EVM ran the +Faucet+ contract's +withdraw+ function, first it called the +require+ function and validated that the requested amount was less than or equal to the maximum allowed withdrawal of 0.1 ether. Then it called the +transfer+ function to send you the ether. Running the +transfer+ function generated an internal transaction that deposited 0.1 ether into your wallet address, from the contract's balance. That's the one shown on the Internal Transactions tab in Etherscan(((range=""endofrange"", startref=""ix_02intro-asciidoc20"")))(((range=""endofrange"", startref=""ix_02intro-asciidoc19""))).(((range=""endofrange"", startref=""ix_02intro-asciidoc14"")))

[[etherscan_withdrawal_internal]]
.Etherscan shows the internal transaction transferring ether out from the contract
image::images/etherscan_withdrawal_internal.png[""Etherscan shows the internal transaction transferring ether out from the contract""]

[[intro_conclusion]]
=== Conclusions

In this chapter, you set up a wallet using MetaMask and funded it using a faucet on the Ropsten test network. You received ether into your wallet's Ethereum address, then you sent ether to the faucet's Ethereum address.

Next, you wrote a faucet contract in Solidity. You used the Remix IDE to compile the contract into EVM bytecode, then used Remix to form a transaction and created the +Faucet+ contract on the Ropsten blockchain. Once created, the +Faucet+ contract had an Ethereum address, and you sent it some ether. Finally, you constructed a transaction to call the +withdraw+ function and successfully asked for 0.1 ether. The contract checked the request and sent you 0.1 ether with an internal transaction.

It may not seem like much, but you've just successfully interacted with software that controls money on a decentralized world computer.

We will do a lot more smart contract programming in <<smart_contracts_chapter>> and learn about best practices and security considerations in <<smart_contract_security>>.(((range=""endofrange"", startref=""ix_02intro-asciidoc0"")))
",12460,False,2072.9873032529176,median
"

#include ""preferencespopup.h""

// Tnz6 includes
#include ""menubarcommandids.h""
#include ""versioncontrol.h""
#include ""levelsettingspopup.h""
#include ""tapp.h""

// TnzQt includes
#include ""toonzqt/tabbar.h""
#include ""toonzqt/menubarcommand.h""
#include ""toonzqt/checkbox.h""
#include ""toonzqt/gutil.h""
#include ""toonzqt/doublefield.h""
#include ""toonzqt/dvdialog.h""
#include ""toonzqt/filefield.h""

// TnzLib includes
#include ""toonz/tscenehandle.h""
#include ""toonz/txshlevelhandle.h""
#include ""toonz/txshleveltypes.h""
#include ""toonz/tscenehandle.h""
#include ""toonz/levelproperties.h""
#include ""toonz/tonionskinmaskhandle.h""

// TnzCore includes
#include ""tsystem.h""

// Qt includes
#include <QHBoxLayout>
#include <QComboBox>
#include <QLabel>
#include <QStackedWidget>
#include <QLineEdit>
#include <QFileDialog>
#include <QFile>
#include <QPushButton>
#include <QApplication>
#include <QMainWindow>
#include <QStringList>
#include <QListWidget>

using namespace DVGui;

//*******************************************************************************************
//    Local namespace
//*******************************************************************************************

namespace
{

static const int unitsCount = 5, inchIdx = 2;
static const QString units[unitsCount] = {""cm"", ""mm"", ""inch"", ""field"", ""pixel""};

enum DpiPolicy { DP_ImageDpi,
				 DP_CustomDpi };

} // namespace

//**********************************************************************************
//    PreferencesPopup::FormatProperties  implementation
//**********************************************************************************

PreferencesPopup::FormatProperties::FormatProperties(PreferencesPopup *parent)
	: DVGui::Dialog(parent, false, true)
{
	setWindowTitle(tr(""Level Settings by File Format""));
	setModal(true); // The underlying selected format should not
	// be changed by the user

	// Main layout
	beginVLayout();

	QGridLayout *gridLayout = new QGridLayout;
	int row = 0;

	// Key values
	QLabel *nameLabel = new QLabel(tr(""Name:""));
	nameLabel->setFixedHeight(20); // Due to DVGui::Dialog's quirky behavior
	gridLayout->addWidget(nameLabel, row, 0, Qt::AlignRight);

	m_name = new DVGui::LineEdit;
	gridLayout->addWidget(m_name, row++, 1);

	QLabel *regExpLabel = new QLabel(tr(""Regular Expression:""));
	gridLayout->addWidget(regExpLabel, row, 0, Qt::AlignRight);

	m_regExp = new DVGui::LineEdit;
	gridLayout->addWidget(m_regExp, row++, 1);

	QLabel *priorityLabel = new QLabel(tr(""Priority""));
	gridLayout->addWidget(priorityLabel, row, 0, Qt::AlignRight);

	m_priority = new DVGui::IntLineEdit;
	gridLayout->addWidget(m_priority, row++, 1);

	gridLayout->setRowMinimumHeight(row++, 20);

	// LevelProperties
	m_dpiPolicy = new QComboBox;
	gridLayout->addWidget(m_dpiPolicy, row++, 1);

	m_dpiPolicy->addItem(QObject::tr(""Image DPI""));
	m_dpiPolicy->addItem(QObject::tr(""Custom DPI""));

	QLabel *dpiLabel = new QLabel(LevelSettingsPopup::tr(""DPI:""));
	gridLayout->addWidget(dpiLabel, row, 0, Qt::AlignRight);

	m_dpi = new DVGui::DoubleLineEdit;
	m_dpi->setRange(1, (std::numeric_limits<double>::max)()); // Tried limits::min(), but input 0 was
	gridLayout->addWidget(m_dpi, row++, 1);					  // then replaced with something * e^-128

	m_premultiply = new DVGui::CheckBox(
		LevelSettingsPopup::tr(""Premultiply""));
	gridLayout->addWidget(m_premultiply, row++, 1);

	m_whiteTransp = new DVGui::CheckBox(
		LevelSettingsPopup::tr(""White As Transparent""));
	gridLayout->addWidget(m_whiteTransp, row++, 1);

	m_doAntialias = new DVGui::CheckBox(
		LevelSettingsPopup::tr(""Add Antialiasing""));
	gridLayout->addWidget(m_doAntialias, row++, 1);

	QLabel *antialiasLabel = new QLabel(
		LevelSettingsPopup::tr(""Antialias Softness:""));
	gridLayout->addWidget(antialiasLabel, row, 0, Qt::AlignRight);

	m_antialias = new DVGui::IntLineEdit(this, 10, 0, 100); // Tried 1, but then m_doAntialias was forcedly
	gridLayout->addWidget(m_antialias, row++, 1);			// initialized to true

	QLabel *subsamplingLabel = new QLabel(
		LevelSettingsPopup::tr(""Subsampling:""));
	gridLayout->addWidget(subsamplingLabel, row, 0, Qt::AlignRight);

	m_subsampling = new DVGui::IntLineEdit(this, 1, 1);
	gridLayout->addWidget(m_subsampling, row++, 1);

	addLayout(gridLayout);

	endVLayout();

	// Establish connections
	bool ret = true;

	ret = connect(m_dpiPolicy, SIGNAL(currentIndexChanged(int)), SLOT(updateEnabledStatus())) && ret;
	ret = connect(m_doAntialias, SIGNAL(clicked()), SLOT(updateEnabledStatus())) && ret;

	assert(ret);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::FormatProperties::updateEnabledStatus()
{
	m_dpi->setEnabled(m_dpiPolicy->currentIndex() == DP_CustomDpi);
	m_antialias->setEnabled(m_doAntialias->isChecked());
}

//-----------------------------------------------------------------------------

void PreferencesPopup::FormatProperties::setLevelFormat(
	const Preferences::LevelFormat &lf)
{
	const LevelOptions &lo = lf.m_options;

	m_name->setText(lf.m_name);
	m_regExp->setText(lf.m_pathFormat.pattern());
	m_priority->setValue(lf.m_priority);

	m_dpiPolicy->setCurrentIndex(lo.m_dpiPolicy == LevelOptions::DP_ImageDpi ? DP_ImageDpi : DP_CustomDpi);
	m_dpi->setValue(lo.m_dpi);
	m_premultiply->setChecked(lo.m_premultiply);
	m_whiteTransp->setChecked(lo.m_whiteTransp);
	m_doAntialias->setChecked(lo.m_antialias > 0);
	m_antialias->setValue(lo.m_antialias);
	m_subsampling->setValue(lo.m_subsampling);

	updateEnabledStatus();
}

//-----------------------------------------------------------------------------

Preferences::LevelFormat PreferencesPopup::FormatProperties::levelFormat() const
{
	Preferences::LevelFormat lf(m_name->text());

	// Assign key values
	lf.m_pathFormat.setPattern(m_regExp->text());
	lf.m_priority = m_priority->getValue();

	// Assign level format values
	lf.m_options.m_dpiPolicy = (m_dpiPolicy->currentIndex() == DP_ImageDpi) ? LevelOptions::DP_ImageDpi : LevelOptions::DP_CustomDpi;
	lf.m_options.m_dpi = m_dpi->getValue();
	lf.m_options.m_subsampling = m_subsampling->getValue();
	lf.m_options.m_antialias = m_doAntialias->isChecked() ? m_antialias->getValue() : 0;
	lf.m_options.m_premultiply = m_premultiply->isChecked();
	lf.m_options.m_whiteTransp = m_whiteTransp->isChecked();

	return lf;
}

//**********************************************************************************
//    PreferencesPopup  implementation
//**********************************************************************************

void PreferencesPopup::onUnitChanged(int index)
{
	m_pref->setUnits(::units[index].toStdString());
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onCameraUnitChanged(int index)
{
	m_pref->setCameraUnits(::units[index].toStdString());
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onScanLevelTypeChanged(const QString &text)
{
	m_pref->setScanLevelType(text.toStdString());
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onMinuteChanged()
{
	m_pref->setAutosavePeriod(m_minuteFld->getValue());
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onChunkSizeChanged()
{
	m_pref->setDefaultTaskChunkSize(m_chunkSizeFld->getValue());
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onBlankCountChanged()
{
	if (m_blanksCount && m_blankColor)
		m_pref->setBlankValues(m_blanksCount->getValue(), m_blankColor->getColor());
	TApp::instance()->getCurrentScene()->notifyPreferenceChanged();
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onOnionPaperThicknessChanged()
{
	if (m_onionPaperThickness) {
		m_pref->setOnionPaperThickness(m_onionPaperThickness->getValue());
		TApp::instance()->getCurrentScene()->notifySceneChanged();
	}
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onBlankColorChanged(const TPixel32 &, bool isDragging)
{
	if (isDragging)
		return;

	if (m_blanksCount && m_blankColor)
		m_pref->setBlankValues(m_blanksCount->getValue(), m_blankColor->getColor());
	TApp::instance()->getCurrentScene()->notifyPreferenceChanged();
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onAutomaticSVNRefreshChanged(int index)
{
	m_pref->enableAutomaticSVNFolderRefresh(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onSVNEnabledChanged(int index)
{
	bool enabled = index == Qt::Checked;
	if (enabled) {
		if (VersionControl::instance()->testSetup())
			m_pref->enableSVN(true);
		else {
			if (m_enableVersionControl)
				m_enableVersionControl->setChecked(false);
		}
	} else
		m_pref->enableSVN(false);
}

//-----------------------------------------------------------------------------

void invalidateIcons(); //implemented in sceneviewer.cpp; in which fucking header  I can put this declaration?!

void PreferencesPopup::onTranspCheckDataChanged(const TPixel32 &, bool isDragging)
{
	if (isDragging)
		return;

	m_pref->setTranspCheckData(m_transpCheckBgColor->getColor(), m_transpCheckInkColor->getColor(), m_transpCheckPaintColor->getColor());

	invalidateIcons();
}

//---------------------------------------------------------------------------------------

void PreferencesPopup::onOnionDataChanged(const TPixel32 &, bool isDragging)
{
	if (isDragging)
		return;
	bool inksOnly = false;
	if (m_inksOnly)
		inksOnly = m_inksOnly->isChecked();
	m_pref->setOnionData(m_frontOnionColor->getColor(), m_backOnionColor->getColor(), inksOnly);

	TApp::instance()->getCurrentScene()->notifySceneChanged();
	TApp::instance()->getCurrentLevel()->notifyLevelViewChange();
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onOnionDataChanged(int)
{
	bool inksOnly = false;
	if (m_inksOnly)
		inksOnly = m_inksOnly->isChecked();
	m_pref->setOnionData(m_frontOnionColor->getColor(), m_backOnionColor->getColor(), inksOnly);

	TApp::instance()->getCurrentScene()->notifySceneChanged();
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onViewValuesChanged()
{
	m_pref->setViewValues(m_viewShrink->getValue(), m_viewStep->getValue());
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onIconSizeChanged()
{
	TDimension size(m_iconSizeLx->getValue(), m_iconSizeLy->getValue());
	if (m_pref->getIconSize() == size)
		return;

	m_pref->setIconSize(size);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onAutoExposeChanged(int index)
{
	m_pref->enableAutoExpose(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onSubsceneFolderChanged(int index)
{
	m_pref->enableSubsceneFolder(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onViewGeneratedMovieChanged(int index)
{
	m_pref->enableGeneratedMovieView(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onXsheetStepChanged()
{
	m_pref->setXsheetStep(m_xsheetStep->getValue());
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onXsheetAutopanChanged(int index)
{
	m_pref->enableXsheetAutopan(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onIgnoreAlphaonColumn1Changed(int index)
{
	m_pref->enableIgnoreAlphaonColumn1(index == Qt::Checked);
}
//-----------------------------------------------------------------------------

void PreferencesPopup::onRewindAfterPlayback(int index)
{
	m_pref->enableRewindAfterPlayback(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onFitToFlipbook(int index)
{
	m_pref->enableFitToFlipbook(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onPreviewAlwaysOpenNewFlip(int index)
{
	m_pref->enablePreviewAlwaysOpenNewFlip(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onAskForOverrideRender(int index)
{
	m_pref->setAskForOverrideRender(index == Qt::Checked);
}
//-----------------------------------------------------------------------------

void PreferencesPopup::onRasterOptimizedMemoryChanged(int index)
{
	if (m_pref->isRasterOptimizedMemory() == (index == Qt::Checked))
		return;

	m_pref->enableRasterOptimizedMemory(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onGetFillOnlySavebox(int index)
{
	if (m_pref->getFillOnlySavebox() == (index == Qt::Checked))
		return;

	m_pref->setFillOnlySavebox(index == Qt::Checked);
	TApp::instance()->getCurrentScene()->notifySceneChanged();
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onSaveUnpaintedInCleanupChanged(int index)
{
	if (m_pref->isSaveUnpaintedInCleanupEnable() == (index == Qt::Checked))
		return;

	m_pref->enableSaveUnpaintedInCleanup(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onMinimizeSaveboxAfterEditing(int index)
{
	m_pref->enableMinimizeSaveboxAfterEditing(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onDefaultViewerChanged(int index)
{
	m_pref->enableDefaultViewer(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onAutoSaveChanged(int index)
{
	m_minuteFld->setEnabled(index == Qt::Checked);
	m_pref->enableAutosave(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onKeyframeTypeChanged(int index)
{
	m_pref->setKeyframeType(index + 2);
}
//-----------------------------------------------------------------------------

void PreferencesPopup::onAutocreationTypeChanged(int index)
{
	m_pref->setAutocreationType(index);
}
//-----------------------------------------------------------------------------

void PreferencesPopup::onAnimationStepChanged()
{
	m_pref->setAnimationStep(m_animationStepField->getValue());
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onLanguageTypeChanged(int index)
{
	m_pref->setCurrentLanguage(index);
	QString currentLanguage = m_pref->getCurrentLanguage();
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onMoveCurrentFrameChanged(int index)
{
	m_pref->enableMoveCurrent(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onReplaceAfterSaveLevelAsChanged(int index)
{
	m_pref->enableReplaceAfterSaveLevelAs(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::setViewerBgColor(const TPixel32 &color, bool isDragging)
{
	m_pref->setViewerBGColor(color, isDragging);
	TApp::instance()->getCurrentScene()->notifySceneChanged();
}

//-----------------------------------------------------------------------------

void PreferencesPopup::setPreviewBgColor(const TPixel32 &color, bool isDragging)
{
	m_pref->setPreviewBGColor(color, isDragging);
	TApp::instance()->getCurrentScene()->notifySceneChanged();
}

//-----------------------------------------------------------------------------

void PreferencesPopup::setChessboardColor1(const TPixel32 &color, bool isDragging)
{
	m_pref->setChessboardColor1(color, isDragging);
	TApp::instance()->getCurrentScene()->notifySceneChanged();
}

//-----------------------------------------------------------------------------

void PreferencesPopup::setChessboardColor2(const TPixel32 &color, bool isDragging)
{
	m_pref->setChessboardColor2(color, isDragging);
	TApp::instance()->getCurrentScene()->notifySceneChanged();
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onColumnIconChange(const QString &value)
{
	m_pref->setColumnIconLoadingPolicy(value == QString(""At Once"")
										   ? Preferences::LoadAtOnce
										   : Preferences::LoadOnDemand);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onOnionSkinVisibilityChanged(int index)
{
	m_pref->enableOnionSkin(index == Qt::Checked);

	m_frontOnionColor->setEnabled(index == Qt::Checked);
	m_backOnionColor->setEnabled(index == Qt::Checked);
	m_inksOnly->setEnabled(index == Qt::Checked);
	m_onionPaperThickness->setEnabled(index == Qt::Checked);

	OnionSkinMask osm = TApp::instance()->getCurrentOnionSkin()->getOnionSkinMask();
	osm.enable(index == Qt::Checked);
	TApp::instance()->getCurrentOnionSkin()->setOnionSkinMask(osm);
	TApp::instance()->getCurrentOnionSkin()->notifyOnionSkinMaskChanged();
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onActualPixelOnSceneModeChanged(int index)
{
	m_pref->enableActualPixelViewOnSceneEditingMode(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onMultiLayerStylePickerChanged(int index)
{
	m_pref->enableMultiLayerStylePicker(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onLevelNameOnEachMarkerChanged(int index)
{
	m_pref->enableLevelNameOnEachMarker(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onInitialLoadTlvCachingBehaviorChanged(int index)
{
	m_pref->setInitialLoadTlvCachingBehavior(index);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onViewerZoomCenterChanged(int index)
{
	m_pref->setViewerZoomCenter(index);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onRemoveSceneNumberFromLoadedLevelNameChanged(int index)
{
	m_pref->enableRemoveSceneNumberFromLoadedLevelName(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onShowRasterImageDarkenBlendedInViewerChanged(int index)
{
	m_pref->enableShowRasterImagesDarkenBlendedInViewer(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onShowFrameNumberWithLettersChanged(int index)
{
	m_pref->enableShowFrameNumberWithLetters(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onPaletteTypeForRasterColorModelChanged(int index)
{
	m_pref->setPaletteTypeOnLoadRasterImageAsColorModel(index);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onShowKeyframesOnCellAreaChanged(int index)
{
	m_pref->enableShowKeyframesOnXsheetCellArea(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onStyleSheetTypeChanged(int index)
{
	m_pref->setCurrentStyleSheet(index);
	QApplication::setOverrideCursor(Qt::WaitCursor);
	QString currentStyle = m_pref->getCurrentStyleSheet();
	qApp->setStyleSheet(currentStyle);
	QApplication::restoreOverrideCursor();
}

//-----------------------------------------------------------------------------
/*
QWidget* PreferencesPopup::create(const QString &lbl, bool def, const char*slot)
{
  DVGui::CheckBox* cb = new DVGui::CheckBox(lbl);
  cb->setMaximumHeight(WidgetHeight);
  cb->setChecked(def);
  bool ret = connect(cb, SIGNAL(stateChanged (int)), slot);
  assert(ret);
  return cb;
}
*/
//-----------------------------------------------------------------------------

void PreferencesPopup::onUndoMemorySizeChanged()
{
	int value = m_undoMemorySize->getValue();
	m_pref->setUndoMemorySize(value);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onDragCellsBehaviourChanged(int index)
{
	m_pref->setDragCellsBehaviour(index);
}

//-----------------------------------------------------------------------------

#ifdef LINETEST
void PreferencesPopup::onLineTestFpsCapture(int index)
{
	if (index == 0)
		m_pref->setLineTestFpsCapture(0);
	if (index == 1)
		m_pref->setLineTestFpsCapture(25);
	else if (index == 2)
		m_pref->setLineTestFpsCapture(30);
}
#endif

//-----------------------------------------------------------------------------

void PreferencesPopup::onLevelsBackupChanged(int index)
{
	m_pref->enableLevelsBackup(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onSceneNumberingChanged(int index)
{
	m_pref->enableSceneNumbering(index == Qt::Checked);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onDefLevelTypeChanged(int index)
{
	if (0 <= index && index < m_defLevelType->count()) {
		int levelType = m_defLevelType->itemData(index).toInt();
		m_pref->setDefLevelType(levelType);
		bool isRaster = levelType != PLI_XSHLEVEL;
		m_defLevelWidth->setEnabled(isRaster);
		m_defLevelHeight->setEnabled(isRaster);
		m_defLevelDpi->setEnabled(isRaster);
	}
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onDefLevelParameterChanged()
{
	double w = m_defLevelWidth->getValue();
	double h = m_defLevelHeight->getValue();
	double dpi = m_defLevelDpi->getValue();
	m_pref->setDefLevelWidth(w);
	m_pref->setDefLevelHeight(h);
	m_pref->setDefLevelDpi(dpi);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::rebuildFormatsList()
{
	const Preferences &prefs = *Preferences::instance();

	m_levelFormatNames->clear();

	int lf, lfCount = prefs.levelFormatsCount();
	for (lf = 0; lf != lfCount; ++lf)
		m_levelFormatNames->addItem(prefs.levelFormat(lf).m_name);

	m_editLevelFormat->setEnabled(m_levelFormatNames->count() > 0);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onAddLevelFormat()
{
	bool ok = true;
	QString formatName = DVGui::getText(
		tr(""New Level Format""), tr(""Assign the new level format name:""),
		tr(""New Format""), &ok);

	if (ok) {
		int formatIdx = Preferences::instance()->addLevelFormat(formatName);
		rebuildFormatsList();

		m_levelFormatNames->setCurrentIndex(formatIdx);
	}
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onRemoveLevelFormat()
{
	Preferences::instance()->removeLevelFormat(m_levelFormatNames->currentIndex());
	rebuildFormatsList();
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onEditLevelFormat()
{
	if (!m_formatProperties) {
		m_formatProperties = new FormatProperties(this);

		bool ret = connect(m_formatProperties, SIGNAL(dialogClosed()), SLOT(onLevelFormatEdited()));
		assert(ret);
	}

	const Preferences::LevelFormat &lf = Preferences::instance()->levelFormat(
		m_levelFormatNames->currentIndex());

	m_formatProperties->setLevelFormat(lf);
	m_formatProperties->show();
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onLevelFormatEdited()
{
	assert(m_formatProperties);

	Preferences &prefs = *Preferences::instance();
	int formatIdx = m_levelFormatNames->currentIndex();

	prefs.removeLevelFormat(formatIdx);
	formatIdx = prefs.addLevelFormat(m_formatProperties->levelFormat());

	rebuildFormatsList();

	m_levelFormatNames->setCurrentIndex(formatIdx);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onShow0ThickLinesChanged(int on)
{
	m_pref->setShow0ThickLines(on);
}

//-----------------------------------------------------------------------------

void PreferencesPopup::onRegionAntialiasChanged(int on)
{
	m_pref->setRegionAntialias(on);
}

//**********************************************************************************
//    PrefencesPopup's  constructor
//**********************************************************************************

PreferencesPopup::PreferencesPopup()
	: QDialog(TApp::instance()->getMainWindow()), m_formatProperties(), m_inksOnly(0), m_blanksCount(0), m_blankColor(0)
{
	setWindowTitle(tr(""Preferences""));
	setObjectName(""PreferencesPopup"");

	m_pref = Preferences::instance();

	//Category List
	QListWidget *categoryList = new QListWidget(this);

	QStackedWidget *stackedWidget = new QStackedWidget(this);

	//---General ------------------------------
	categoryList->addItem(tr(""General""));

	CheckBox *useDefaultViewerCB = new CheckBox(tr(""Use Default Viewer for Movie Formats""), this);
	CheckBox *minimizeRasterMemoryCB = new CheckBox(tr(""Minimize Raster Memory Fragmentation *""), this);
	CheckBox *autoSaveCB = new CheckBox(tr(""Save Automatically Every Minutes""));
	m_minuteFld = new DVGui::IntLineEdit(this, 15, 1, 60);
	CheckBox *replaceAfterSaveLevelAsCB = new CheckBox(tr(""Replace Toonz Level after SaveLevelAs command""), this);

	m_cellsDragBehaviour = new QComboBox();
	m_undoMemorySize = new DVGui::IntLineEdit(this, m_pref->getUndoMemorySize(), 0, 2000);
	m_levelsBackup = new CheckBox(tr(""Backup Animation Levels when Saving""));
	m_chunkSizeFld = new DVGui::IntLineEdit(this, m_pref->getDefaultTaskChunkSize(), 1, 2000);
	CheckBox *sceneNumberingCB = new CheckBox(tr(""Show Info in Rendered Frames""));

	QLabel *note_general = new QLabel(tr(""* Changes will take effect the next time you run Toonz""));
	note_general->setStyleSheet(""font-size: 10px; font: italic;"");

	//--- Interface ------------------------------
	categoryList->addItem(tr(""Interface""));

	QComboBox *languageType = 0;
	QStringList languageList;
	int currentIndex = 0;
	for (int i = 0; i < m_pref->getLanguageCount(); i++) {
		QString string = m_pref->getLanguage(i);
		if (string == m_pref->getCurrentLanguage())
			currentIndex = i;
		languageList.push_back(string);
	}

	if (languageList.size() > 1) {
		languageType = new QComboBox(this);
		languageType->addItems(languageList);
		languageType->setCurrentIndex(currentIndex);
	}
	QComboBox *styleSheetType = new QComboBox(this);
	QComboBox *unitOm = new QComboBox(this);
	QComboBox *cameraUnitOm = new QComboBox(this);
	m_iconSizeLx = new DVGui::IntLineEdit(this, 80, 10, 400);
	m_iconSizeLy = new DVGui::IntLineEdit(this, 60, 10, 400);
	m_viewShrink = new DVGui::IntLineEdit(this, 1, 1, 20);
	m_viewStep = new DVGui::IntLineEdit(this, 1, 1, 20);

	CheckBox *moveCurrentFrameCB = new CheckBox(tr(""Move Current Frame by Clicking on Xsheet / Numerical Columns Cell Area""), this);
	//Viewer BG color
	m_viewerBgColorFld = new ColorField(this, false, m_pref->getViewerBgColor());
	//Preview BG color
	m_previewBgColorFld = new ColorField(this, false, m_pref->getPreviewBgColor());
	//bg chessboard colors
	TPixel32 col1, col2;
	m_pref->getChessboardColors(col1, col2);
	m_chessboardColor1Fld = new ColorField(this, false, col1);
	m_chessboardColor2Fld = new ColorField(this, false, col2);
	CheckBox *openFlipbookAfterCB = new CheckBox(tr(""Open Flipbook after Rendering""), this);
	CheckBox *actualPixelOnSceneModeCB = new CheckBox(tr(""Enable Actual Pixel View on Scene Editing Mode""), this);
	CheckBox *levelNameOnEachMarkerCB = new CheckBox(tr(""Display Level Name on Each Marker""), this);
	CheckBox *showRasterImageDarkenBlendedInViewerCB = new CheckBox(tr(""Show Raster Images Darken Blended in Camstand View""), this);
	CheckBox *showShowFrameNumberWithLettersCB = new CheckBox(tr(""Show \\""ABC\\"" Appendix to the Frame Number in Xsheet Cell""), this);
	QComboBox *viewerZoomCenterComboBox = new QComboBox(this);

	QLabel *note_interface = new QLabel(tr(""* Changes will take effect the next time you run Toonz""));
	note_interface->setStyleSheet(""font-size: 10px; font: italic;"");

	//--- Visualization ------------------------------
	categoryList->addItem(tr(""Visualization""));
	CheckBox *show0ThickLinesCB = new CheckBox(tr(""Show Lines with Thickness 0""), this);
	CheckBox *regionAntialiasCB = new CheckBox(tr(""Antialiased region boundaries""), this);

	//--- Loading ------------------------------
	categoryList->addItem(tr(""Loading""));

	CheckBox *exposeLoadedLevelsCB = new CheckBox(tr(""Expose Loaded Levels in Xsheet""), this);
	CheckBox *createSubfolderCB = new CheckBox(tr(""Create Sub-folder when Importing Sub-xsheet""), this);
	//Column Icon
	m_columnIconOm = new QComboBox(this);
	QComboBox *initialLoadTlvCachingBehaviorComboBox = new QComboBox(this);
	CheckBox *removeSceneNumberFromLoadedLevelNameCB = new CheckBox(tr(""Automatically Remove Scene Number from Loaded Level Name""), this);

	m_levelFormatNames = new QComboBox;
	m_addLevelFormat = new QPushButton(""+"");
	m_removeLevelFormat = new QPushButton(""-"");
	m_editLevelFormat = new QPushButton(tr(""Edit""));

	QComboBox *paletteTypeForRasterColorModelComboBox = new QComboBox(this);

	//--- Drawing ------------------------------
	categoryList->addItem(tr(""Drawing""));

#ifndef BRAVO
	m_defScanLevelType = new QComboBox(this);
#endif
	m_defLevelType = new QComboBox(this);
	m_defLevelWidth = new MeasuredDoubleLineEdit(0);
	m_defLevelHeight = new MeasuredDoubleLineEdit(0);
	m_defLevelDpi = new DoubleLineEdit(0, 66.76);
	m_autocreationType = new QComboBox(this);

	CheckBox *keepOriginalCleanedUpCB = new CheckBox(tr(""Keep Original Cleaned Up Drawings As Backup""), this);
	CheckBox *multiLayerStylePickerCB = new CheckBox(tr(""Multi Layer Style Picker : Switch Levels by Picking""), this);
	CheckBox *useSaveboxToLimitFillingOpCB = new CheckBox(tr(""Use the TLV Savebox to Limit Filling Operations""), this);
	CheckBox *minimizeSaveboxAfterEditingCB = new CheckBox(tr(""Minimize Savebox after Editing""), this);

	//--- Xsheet ------------------------------
	categoryList->addItem(tr(""Xsheet""));

	CheckBox *xsheetAutopanDuringPlaybackCB = new CheckBox(tr(""Xsheet Autopan during Playback""), this);
	m_xsheetStep = new DVGui::IntLineEdit(this, Preferences::instance()->getXsheetStep(), 0);
	m_cellsDragBehaviour = new QComboBox();
	CheckBox *ignoreAlphaonColumn1CB = new CheckBox(tr(""Ignore Alpha Channel on Levels in Column 1""), this);
	CheckBox *showKeyframesOnCellAreaCB = new CheckBox(tr(""Show Keyframes on Cell Area""), this);

	//--- Animation ------------------------------
	categoryList->addItem(tr(""Animation""));

	m_keyframeType = new QComboBox(this);
	m_animationStepField = new DVGui::IntLineEdit(this, 1, 1, 500);

	//--- Preview ------------------------------
	categoryList->addItem(tr(""Preview""));

	m_blanksCount = new DVGui::IntLineEdit(this, 0, 0, 1000);
	m_blankColor = new ColorField(this, false, TPixel::Black);
	CheckBox *rewindAfterPlaybackCB = new CheckBox(tr(""Rewind after Playback""), this);
	CheckBox *displayInNewFlipBookCB = new CheckBox(tr(""Display in a New Flipbook Window""), this);
	CheckBox *fitToFlipbookCB = new CheckBox(tr(""Fit to Flipbook""), this);

	//--- Onion Skin ------------------------------
	categoryList->addItem(tr(""Onion Skin""));

	TPixel32 frontColor, backColor;
	bool onlyInks;
	m_pref->getOnionData(frontColor, backColor, onlyInks);
	m_onionSkinVisibility = new CheckBox(tr(""Onion Skin ON""));
	m_frontOnionColor = new ColorField(this, false, frontColor);
	m_backOnionColor = new ColorField(this, false, backColor);
	m_inksOnly = new DVGui::CheckBox(tr(""Display Lines Only ""));
	m_inksOnly->setChecked(onlyInks);

	int thickness = m_pref->getOnionPaperThickness();
	m_onionPaperThickness = new DVGui::IntLineEdit(this, thickness, 0, 100);

	//--- Transparency Check ------------------------------
	categoryList->addItem(tr(""Transparency Check""));

	TPixel32 bgColor, inkColor, paintColor;
	m_pref->getTranspCheckData(bgColor, inkColor, paintColor);
	m_transpCheckInkColor = new ColorField(this, false, inkColor);
	m_transpCheckBgColor = new ColorField(this, false, bgColor);
	m_transpCheckPaintColor = new ColorField(this, false, paintColor);

	//--- Version Control ------------------------------
	categoryList->addItem(tr(""Version Control""));
	m_enableVersionControl = new DVGui::CheckBox(tr(""Enable Version Control*""));
	CheckBox *autoRefreshFolderContentsCB = new CheckBox(tr(""Automatically Refresh Folder Contents""), this);

	QLabel *note_version = new QLabel(tr(""* Changes will take effect the next time you run Toonz""));
	note_version->setStyleSheet(""font-size: 10px; font: italic;"");

	/*--- set default parameters ---*/
	categoryList->setFixedWidth(160);
	categoryList->setCurrentRow(0);
	categoryList->setAlternatingRowColors(true);
	//--- General ------------------------------
	useDefaultViewerCB->setChecked(m_pref->isDefaultViewerEnabled());
	minimizeRasterMemoryCB->setChecked(m_pref->isRasterOptimizedMemory());
	autoSaveCB->setChecked(m_pref->isAutosaveEnabled());
	m_minuteFld->setValue(m_pref->getAutosavePeriod());
	m_minuteFld->setEnabled(m_pref->isAutosaveEnabled());
	replaceAfterSaveLevelAsCB->setChecked(m_pref->isReplaceAfterSaveLevelAsEnabled());

	QStringList dragCellsBehaviourList;
	dragCellsBehaviourList << tr(""Cells Only"") << tr(""Cells and Column Data"");
	m_cellsDragBehaviour->addItems(dragCellsBehaviourList);
	m_cellsDragBehaviour->setCurrentIndex(m_pref->getDragCellsBehaviour());
	m_levelsBackup->setChecked(m_pref->isLevelsBackupEnabled());
	sceneNumberingCB->setChecked(m_pref->isSceneNumberingEnabled());

	//--- Interface ------------------------------
	QStringList styleSheetList;
	for (int i = 0; i < m_pref->getStyleSheetCount(); i++) {
		QString string = m_pref->getStyleSheet(i);
		if (string == m_pref->getCurrentStyleSheet())
			currentIndex = i;
		TFilePath path(string.toStdWString());
		styleSheetList.push_back(QString::fromStdWString(path.getWideName()));
	}
	styleSheetType->addItems(styleSheetList);
	styleSheetType->setCurrentIndex(currentIndex);

	QStringList type;
	type << tr(""cm"") << tr(""mm"") << tr(""inch"") << tr(""field"");
	unitOm->addItems(type);
	int idx = std::find(::units, ::units + ::unitsCount, m_pref->getUnits()) - ::units;
	unitOm->setCurrentIndex((idx < ::unitsCount) ? idx : ::inchIdx);
	cameraUnitOm->addItems(type);

	idx = std::find(::units, ::units + ::unitsCount, m_pref->getCameraUnits()) - ::units;
	cameraUnitOm->setCurrentIndex((idx < ::unitsCount) ? idx : ::inchIdx);

	m_iconSizeLx->setValue(m_pref->getIconSize().lx);
	m_iconSizeLy->setValue(m_pref->getIconSize().ly);
	int shrink, step;
	m_pref->getViewValues(shrink, step);
	m_viewShrink->setValue(shrink);
	m_viewStep->setValue(step);
	moveCurrentFrameCB->setChecked(m_pref->isMoveCurrentEnabled());
	openFlipbookAfterCB->setChecked(m_pref->isGeneratedMovieViewEnabled());
	actualPixelOnSceneModeCB->setChecked(m_pref->isActualPixelViewOnSceneEditingModeEnabled());
	levelNameOnEachMarkerCB->setChecked(m_pref->isLevelNameOnEachMarkerEnabled());
	showRasterImageDarkenBlendedInViewerCB->setChecked(m_pref->isShowRasterImagesDarkenBlendedInViewerEnabled());
	showShowFrameNumberWithLettersCB->setChecked(m_pref->isShowFrameNumberWithLettersEnabled());
	QStringList zoomCenters;
	zoomCenters << tr(""Mouse Cursor"")
				<< tr(""Viewer Center"");
	viewerZoomCenterComboBox->addItems(zoomCenters);
	viewerZoomCenterComboBox->setCurrentIndex(m_pref->getViewerZoomCenter());

	//--- Visualization ------------------------------
	show0ThickLinesCB->setChecked(m_pref->getShow0ThickLines());
	regionAntialiasCB->setChecked(m_pref->getRegionAntialias());

	//--- Loading ------------------------------
	exposeLoadedLevelsCB->setChecked(m_pref->isAutoExposeEnabled());
	QStringList behaviors;
	behaviors << tr(""On Demand"") << tr(""All Icons"") << tr(""All Icons & Images"");
	initialLoadTlvCachingBehaviorComboBox->addItems(behaviors);
	initialLoadTlvCachingBehaviorComboBox->setCurrentIndex(m_pref->getInitialLoadTlvCachingBehavior());
	QStringList formats;
	formats << tr(""At Once"") << tr(""On Demand"");
	m_columnIconOm->addItems(formats);
	if (m_pref->getColumnIconLoadingPolicy() == Preferences::LoadAtOnce)
		m_columnIconOm->setCurrentIndex(m_columnIconOm->findText(tr(""At Once"")));
	else
		m_columnIconOm->setCurrentIndex(m_columnIconOm->findText(tr(""On Demand"")));
	removeSceneNumberFromLoadedLevelNameCB->setChecked(m_pref->isRemoveSceneNumberFromLoadedLevelNameEnabled());
	createSubfolderCB->setChecked(m_pref->isSubsceneFolderEnabled());

	m_addLevelFormat->setFixedSize(20, 20);
	m_removeLevelFormat->setFixedSize(20, 20);

	rebuildFormatsList();

	QStringList paletteTypes;
	paletteTypes << tr(""Pick Every Colors as Different Styles"") << tr(""Integrate Similar Colors as One Style"");
	paletteTypeForRasterColorModelComboBox->addItems(paletteTypes);
	paletteTypeForRasterColorModelComboBox->setCurrentIndex(m_pref->getPaletteTypeOnLoadRasterImageAsColorModel());

	//--- Drawing ------------------------------
	keepOriginalCleanedUpCB->setChecked(m_pref->isSaveUnpaintedInCleanupEnable());
	multiLayerStylePickerCB->setChecked(m_pref->isMultiLayerStylePickerEnabled());
	minimizeSaveboxAfterEditingCB->setChecked(m_pref->isMinimizeSaveboxAfterEditing());
	useSaveboxToLimitFillingOpCB->setChecked(m_pref->getFillOnlySavebox());

#ifndef BRAVO
	QStringList scanLevelTypes;
	scanLevelTypes << ""tif""
				   << ""png"";
	m_defScanLevelType->addItems(scanLevelTypes);
	m_defScanLevelType->setCurrentIndex(m_defScanLevelType->findText(m_pref->getScanLevelType()));
#endif
	QStringList levelTypes;
	m_defLevelType->addItem((""Toonz Vector Level""), PLI_XSHLEVEL);
	m_defLevelType->addItem((""Toonz Raster Level""), TZP_XSHLEVEL);
	m_defLevelType->addItem((""Raster Level""), OVL_XSHLEVEL);
	m_defLevelType->setCurrentIndex(0);

	for (int i = 0; i < m_defLevelType->count(); i++) {
		if (m_defLevelType->itemData(i).toInt() == m_pref->getDefLevelType()) {
			m_defLevelType->setCurrentIndex(i);
			onDefLevelTypeChanged(i);
			break;
		}
	}

	m_defLevelWidth->setRange(0.1, (std::numeric_limits<double>::max)());
	m_defLevelWidth->setMeasure(""level.lx"");
	m_defLevelWidth->setValue(m_pref->getDefLevelWidth());
	m_defLevelHeight->setRange(0.1, (std::numeric_limits<double>::max)());
	m_defLevelHeight->setMeasure(""level.ly"");
	m_defLevelHeight->setValue(m_pref->getDefLevelHeight());
	m_defLevelDpi->setRange(0.1, (std::numeric_limits<double>::max)());
	m_defLevelDpi->setValue(m_pref->getDefLevelDpi());
	QStringList autocreationTypes;
	autocreationTypes << tr(""Disabled"")
					  << tr(""Enabled"")
					  << tr(""Use Xsheet as Animation Sheet"");
	m_autocreationType->addItems(autocreationTypes);
	int autocreationType = m_pref->getAutocreationType();
	m_autocreationType->setCurrentIndex(autocreationType);

	//--- Xsheet ------------------------------
	xsheetAutopanDuringPlaybackCB->setChecked(m_pref->isXsheetAutopanEnabled());
	m_cellsDragBehaviour->addItem(tr(""Cells Only""));
	m_cellsDragBehaviour->addItem(tr(""Cells and Column Data""));
	m_cellsDragBehaviour->setCurrentIndex(m_pref->getDragCellsBehaviour());
	ignoreAlphaonColumn1CB->setChecked(m_pref->isIgnoreAlphaonColumn1Enabled());
	showKeyframesOnCellAreaCB->setChecked(m_pref->isShowKeyframesOnXsheetCellAreaEnabled());

	//--- Animation ------------------------------
	QStringList list;
	list << tr(""Linear"") << tr(""Speed In / Speed Out"") << tr(""Ease In / Ease Out"") << tr(""Ease In / Ease Out %"");
	m_keyframeType->addItems(list);
	int keyframeType = m_pref->getKeyframeType();
	m_keyframeType->setCurrentIndex(keyframeType - 2);
	m_animationStepField->setValue(m_pref->getAnimationStep());

	//--- Preview ------------------------------
	int blanksCount;
	TPixel32 blankColor;
	m_pref->getBlankValues(blanksCount, blankColor);
	m_blanksCount->setValue(blanksCount);
	m_blankColor->setColor(blankColor);

	rewindAfterPlaybackCB->setChecked(m_pref->rewindAfterPlaybackEnabled());
	displayInNewFlipBookCB->setChecked(m_pref->previewAlwaysOpenNewFlipEnabled());
	fitToFlipbookCB->setChecked(m_pref->fitToFlipbookEnabled());

	//--- Onion Skin ------------------------------
	m_onionSkinVisibility->setChecked(m_pref->isOnionSkinEnabled());
	m_frontOnionColor->setEnabled(m_pref->isOnionSkinEnabled());
	m_backOnionColor->setEnabled(m_pref->isOnionSkinEnabled());
	m_inksOnly->setEnabled(m_pref->isOnionSkinEnabled());

	//--- Version Control ------------------------------
	m_enableVersionControl->setChecked(m_pref->isSVNEnabled());
	autoRefreshFolderContentsCB->setChecked(m_pref->isAutomaticSVNFolderRefreshEnabled());

	/*--- layout ---*/

	QHBoxLayout *mainLayout = new QHBoxLayout();
	mainLayout->setMargin(0);
	mainLayout->setSpacing(0);
	{
		//Category
		QVBoxLayout *categoryLayout = new QVBoxLayout();
		categoryLayout->setMargin(5);
		categoryLayout->setSpacing(10);
		{
			categoryLayout->addWidget(new QLabel(tr(""Category""), this), 0, Qt::AlignLeft | Qt::AlignVCenter);
			categoryLayout->addWidget(categoryList, 1);
		}
		mainLayout->addLayout(categoryLayout, 0);

		//--- General --------------------------
		QWidget *generalBox = new QWidget(this);
		QVBoxLayout *generalFrameLay = new QVBoxLayout();
		generalFrameLay->setMargin(15);
		generalFrameLay->setSpacing(10);
		{
			generalFrameLay->addWidget(useDefaultViewerCB, 0, Qt::AlignLeft | Qt::AlignVCenter);
			generalFrameLay->addWidget(minimizeRasterMemoryCB, 0, Qt::AlignLeft | Qt::AlignVCenter);
			QHBoxLayout *saveAutoLay = new QHBoxLayout();
			saveAutoLay->setMargin(0);
			saveAutoLay->setSpacing(15);
			{
				saveAutoLay->addWidget(autoSaveCB, 0);
				saveAutoLay->addWidget(m_minuteFld, 0);
				saveAutoLay->addStretch(1);
			}
			generalFrameLay->addLayout(saveAutoLay, 0);

			//Unit, CameraUnit
			QGridLayout *unitLay = new QGridLayout();
			unitLay->setMargin(0);
			unitLay->setHorizontalSpacing(5);
			unitLay->setVerticalSpacing(10);
			{
				unitLay->addWidget(new QLabel(tr(""Undo Memory Size (MB)""), this), 0, 0, Qt::AlignRight | Qt::AlignVCenter);
				unitLay->addWidget(m_undoMemorySize, 0, 1);

				unitLay->addWidget(new QLabel(tr(""Render Task Chunk Size:""), this), 1, 0, Qt::AlignRight | Qt::AlignVCenter);
				unitLay->addWidget(m_chunkSizeFld, 1, 1);
			}
			unitLay->setColumnStretch(0, 0);
			unitLay->setColumnStretch(1, 0);
			unitLay->setColumnStretch(2, 1);

			generalFrameLay->addLayout(unitLay, 0);

			generalFrameLay->addWidget(replaceAfterSaveLevelAsCB, 0, Qt::AlignLeft | Qt::AlignVCenter);
			generalFrameLay->addWidget(m_levelsBackup, 0, Qt::AlignLeft | Qt::AlignVCenter);
			generalFrameLay->addWidget(sceneNumberingCB, 0, Qt::AlignLeft | Qt::AlignVCenter);
			generalFrameLay->addStretch(1);

			generalFrameLay->addWidget(note_general, 0);
		}
		generalBox->setLayout(generalFrameLay);
		stackedWidget->addWidget(generalBox);

		//--- Interface --------------------------
		QWidget *userInterfaceBox = new QWidget(this);
		QVBoxLayout *userInterfaceFrameLay = new QVBoxLayout();
		userInterfaceFrameLay->setMargin(15);
		userInterfaceFrameLay->setSpacing(10);
		{
			QGridLayout *styleLay = new QGridLayout();
			styleLay->setMargin(0);
			styleLay->setHorizontalSpacing(5);
			styleLay->setVerticalSpacing(10);
			{
				styleLay->addWidget(new QLabel(tr(""Style:"")), 0, 0, Qt::AlignRight | Qt::AlignVCenter);
				styleLay->addWidget(styleSheetType, 0, 1);

				styleLay->addWidget(new QLabel(tr(""Unit:""), this), 1, 0, Qt::AlignRight | Qt::AlignVCenter);
				styleLay->addWidget(unitOm, 1, 1);

				styleLay->addWidget(new QLabel(tr(""Camera Unit:""), this), 2, 0, Qt::AlignRight | Qt::AlignVCenter);
				styleLay->addWidget(cameraUnitOm, 2, 1);
			}
			styleLay->setColumnStretch(0, 0);
			styleLay->setColumnStretch(1, 0);
			styleLay->setColumnStretch(2, 1);
			userInterfaceFrameLay->addLayout(styleLay, 0);

			userInterfaceFrameLay->addWidget(openFlipbookAfterCB, 0, Qt::AlignLeft | Qt::AlignVCenter);
			userInterfaceFrameLay->addWidget(moveCurrentFrameCB, 0, Qt::AlignLeft | Qt::AlignVCenter);
			userInterfaceFrameLay->addWidget(actualPixelOnSceneModeCB, 0, Qt::AlignLeft | Qt::AlignVCenter);
			userInterfaceFrameLay->addWidget(levelNameOnEachMarkerCB, 0, Qt::AlignLeft | Qt::AlignVCenter);
			userInterfaceFrameLay->addWidget(showRasterImageDarkenBlendedInViewerCB, 0, Qt::AlignLeft | Qt::AlignVCenter);
			userInterfaceFrameLay->addWidget(showShowFrameNumberWithLettersCB, 0, Qt::AlignLeft | Qt::AlignVCenter);

			QGridLayout *bgColorsLay = new QGridLayout();
			bgColorsLay->setMargin(0);
			bgColorsLay->setHorizontalSpacing(5);
			bgColorsLay->setVerticalSpacing(10);
			{
				bgColorsLay->addWidget(new QLabel(tr(""Icon Size *""), this), 0, 0, Qt::AlignRight | Qt::AlignVCenter);
				bgColorsLay->addWidget(m_iconSizeLx, 0, 1);
				bgColorsLay->addWidget(new QLabel(tr(""X""), this), 0, 2, Qt::AlignCenter);
				bgColorsLay->addWidget(m_iconSizeLy, 0, 3);

				bgColorsLay->addWidget(new QLabel(tr(""Viewer  Shrink""), this), 1, 0, Qt::AlignRight | Qt::AlignVCenter);
				bgColorsLay->addWidget(m_viewShrink, 1, 1);
				bgColorsLay->addWidget(new QLabel(tr(""Step""), this), 1, 3, Qt::AlignRight | Qt::AlignVCenter);
				bgColorsLay->addWidget(m_viewStep, 1, 4);

				bgColorsLay->addWidget(new QLabel(tr(""Viewer BG Color""), this), 2, 0, Qt::AlignRight | Qt::AlignVCenter);
				bgColorsLay->addWidget(m_viewerBgColorFld, 2, 1, 1, 5);

				bgColorsLay->addWidget(new QLabel(tr(""Preview BG Color""), this), 3, 0, Qt::AlignRight | Qt::AlignVCenter);
				bgColorsLay->addWidget(m_previewBgColorFld, 3, 1, 1, 5);

				bgColorsLay->addWidget(new QLabel(tr(""ChessBoard Color 1""), this), 4, 0, Qt::AlignRight | Qt::AlignVCenter);
				bgColorsLay->addWidget(m_chessboardColor1Fld, 4, 1, 1, 5);

				bgColorsLay->addWidget(new QLabel(tr(""Chessboard Color 2""), this), 5, 0, Qt::AlignRight | Qt::AlignVCenter);
				bgColorsLay->addWidget(m_chessboardColor2Fld, 5, 1, 1, 5);

				bgColorsLay->addWidget(new QLabel(tr(""Viewer Zoom Center""), this), 6, 0, Qt::AlignRight | Qt::AlignVCenter);
				bgColorsLay->addWidget(viewerZoomCenterComboBox, 6, 1, 1, 4);

				if (languageType) {
					bgColorsLay->addWidget(new QLabel(tr(""Language *:"")), 7, 0, Qt::AlignRight | Qt::AlignVCenter);
					bgColorsLay->addWidget(languageType, 7, 1, 1, 4);
				}
			}
			bgColorsLay->setColumnStretch(0, 0);
			bgColorsLay->setColumnStretch(1, 0);
			bgColorsLay->setColumnStretch(2, 0);
			bgColorsLay->setColumnStretch(3, 0);
			bgColorsLay->setColumnStretch(4, 0);
			bgColorsLay->setColumnStretch(5, 1);
			userInterfaceFrameLay->addLayout(bgColorsLay, 0);

			userInterfaceFrameLay->addStretch(1);

			userInterfaceFrameLay->addWidget(note_interface, 0);
		}
		userInterfaceBox->setLayout(userInterfaceFrameLay);
		stackedWidget->addWidget(userInterfaceBox);

		//--- Visualization ---------------------
		QWidget *visualizatonBox = new QWidget(this);
		QVBoxLayout *visualizatonFrameLay = new QVBoxLayout();
		visualizatonFrameLay->setMargin(15);
		visualizatonFrameLay->setSpacing(10);
		{
			visualizatonFrameLay->addWidget(show0ThickLinesCB, 0);
			visualizatonFrameLay->addWidget(regionAntialiasCB, 0);
			visualizatonFrameLay->addStretch(1);
		}
		visualizatonBox->setLayout(visualizatonFrameLay);
		stackedWidget->addWidget(visualizatonBox);

		//--- Loading --------------------------
		QWidget *loadingBox = new QWidget(this);
		QVBoxLayout *loadingFrameLay = new QVBoxLayout();
		loadingFrameLay->setMargin(15);
		loadingFrameLay->setSpacing(10);
		{
			loadingFrameLay->addWidget(exposeLoadedLevelsCB, 0, Qt::AlignLeft | Qt::AlignVCenter);
			loadingFrameLay->addWidget(createSubfolderCB, 0, Qt::AlignLeft | Qt::AlignVCenter);
			loadingFrameLay->addWidget(removeSceneNumberFromLoadedLevelNameCB, 0, Qt::AlignLeft | Qt::AlignVCenter);

			QGridLayout *cacheLay = new QGridLayout();
			cacheLay->setMargin(0);
			cacheLay->setHorizontalSpacing(5);
			cacheLay->setVerticalSpacing(10);
			{
				cacheLay->addWidget(new QLabel(tr(""Default TLV Caching Behavior"")), 0, 0, Qt::AlignRight | Qt::AlignVCenter);
				cacheLay->addWidget(initialLoadTlvCachingBehaviorComboBox, 0, 1);

				cacheLay->addWidget(new QLabel(tr(""Column Icon""), this), 1, 0, Qt::AlignRight | Qt::AlignVCenter);
				cacheLay->addWidget(m_columnIconOm, 1, 1);

				cacheLay->addWidget(new QLabel(tr(""Level Settings by File Format:"")), 2, 0, Qt::AlignRight | Qt::AlignVCenter);
				cacheLay->addWidget(m_levelFormatNames, 2, 1);
				cacheLay->addWidget(m_addLevelFormat, 2, 2);
				cacheLay->addWidget(m_removeLevelFormat, 2, 3);
				cacheLay->addWidget(m_editLevelFormat, 2, 4);

				cacheLay->addWidget(new QLabel(tr(""Palette Type on Loading Raster Image as Color Model"")), 3, 0, Qt::AlignRight | Qt::AlignVCenter);
				cacheLay->addWidget(paletteTypeForRasterColorModelComboBox, 3, 1, 1, 5);
			}
			cacheLay->setColumnStretch(0, 0);
			cacheLay->setColumnStretch(1, 0);
			cacheLay->setColumnStretch(2, 0);
			cacheLay->setColumnStretch(3, 0);
			cacheLay->setColumnStretch(4, 0);
			cacheLay->setColumnStretch(5, 1);
			loadingFrameLay->addLayout(cacheLay, 0);

			loadingFrameLay->addStretch(1);
		}
		loadingBox->setLayout(loadingFrameLay);
		stackedWidget->addWidget(loadingBox);

		//--- Drawing --------------------------
		QWidget *drawingBox = new QWidget(this);
		QVBoxLayout *drawingFrameLay = new QVBoxLayout();
		drawingFrameLay->setMargin(15);
		drawingFrameLay->setSpacing(10);
		{
			QGridLayout *drawingTopLay = new QGridLayout();
			drawingTopLay->setVerticalSpacing(10);
			drawingTopLay->setHorizontalSpacing(15);
			drawingTopLay->setMargin(0);
			{
#ifndef BRAVO
				drawingTopLay->addWidget(new QLabel(tr(""Scan File Format:"")), 0, 0, Qt::AlignRight);
				drawingTopLay->addWidget(m_defScanLevelType, 0, 1, 1, 3);
#endif

				drawingTopLay->addWidget(new QLabel(tr(""Default Level Type:"")), 1, 0, Qt::AlignRight);
				drawingTopLay->addWidget(m_defLevelType, 1, 1, 1, 3);

				drawingTopLay->addWidget(new QLabel(tr(""Width:"")), 2, 0, Qt::AlignRight);
				drawingTopLay->addWidget(m_defLevelWidth, 2, 1);
				drawingTopLay->addWidget(new QLabel(tr(""  Height:"")), 2, 2, Qt::AlignRight);
				drawingTopLay->addWidget(m_defLevelHeight, 2, 3);

				drawingTopLay->addWidget(new QLabel(tr(""DPI:"")), 3, 0, Qt::AlignRight);
				drawingTopLay->addWidget(m_defLevelDpi, 3, 1);

				drawingTopLay->addWidget(new QLabel(tr(""Autocreation:"")), 4, 0, Qt::AlignRight);
				drawingTopLay->addWidget(m_autocreationType, 4, 1, 1, 3);
			}
			drawingFrameLay->addLayout(drawingTopLay, 0);

			drawingFrameLay->addWidget(keepOriginalCleanedUpCB, 0, Qt::AlignLeft | Qt::AlignVCenter);
			drawingFrameLay->addWidget(minimizeSaveboxAfterEditingCB, 0, Qt::AlignLeft | Qt::AlignVCenter); //6.4
			drawingFrameLay->addWidget(useSaveboxToLimitFillingOpCB, 0, Qt::AlignLeft | Qt::AlignVCenter);
			drawingFrameLay->addWidget(multiLayerStylePickerCB, 0, Qt::AlignLeft | Qt::AlignVCenter);
			drawingFrameLay->addStretch(1);
		}
		drawingBox->setLayout(drawingFrameLay);
		stackedWidget->addWidget(drawingBox);

		//--- Xsheet --------------------------
		QWidget *xsheetBox = new QWidget(this);
		QGridLayout *xsheetFrameLay = new QGridLayout();
		xsheetFrameLay->setMargin(15);
		xsheetFrameLay->setHorizontalSpacing(15);
		xsheetFrameLay->setVerticalSpacing(10);
		{
			xsheetFrameLay->addWidget(new QLabel(tr(""Next/Previous Step Frames:"")), 0, 0, Qt::AlignRight | Qt::AlignVCenter);
			xsheetFrameLay->addWidget(m_xsheetStep, 0, 1);

			xsheetFrameLay->addWidget(xsheetAutopanDuringPlaybackCB, 1, 0, 1, 2);

			xsheetFrameLay->addWidget(new QLabel(tr(""Cell-dragging Behaviour:"")), 2, 0, Qt::AlignRight | Qt::AlignVCenter);
			xsheetFrameLay->addWidget(m_cellsDragBehaviour, 2, 1);

			xsheetFrameLay->addWidget(ignoreAlphaonColumn1CB, 3, 0, 1, 2);
			xsheetFrameLay->addWidget(showKeyframesOnCellAreaCB, 4, 0, 1, 2);
		}
		xsheetFrameLay->setColumnStretch(0, 0);
		xsheetFrameLay->setColumnStretch(1, 0);
		xsheetFrameLay->setColumnStretch(2, 1);
		xsheetFrameLay->setRowStretch(5, 1);
		xsheetBox->setLayout(xsheetFrameLay);
		stackedWidget->addWidget(xsheetBox);

		//--- Animation --------------------------
		QWidget *animationBox = new QWidget(this);
		QGridLayout *animationFrameLay = new QGridLayout();
		animationFrameLay->setMargin(15);
		animationFrameLay->setHorizontalSpacing(15);
		animationFrameLay->setVerticalSpacing(10);
		{
			animationFrameLay->addWidget(new QLabel(tr(""Default Interpolation:"")), 0, 0, Qt::AlignRight | Qt::AlignVCenter);
			animationFrameLay->addWidget(m_keyframeType, 0, 1);

			animationFrameLay->addWidget(new QLabel(tr(""Animation Step:"")), 1, 0, Qt::AlignRight | Qt::AlignVCenter);
			animationFrameLay->addWidget(m_animationStepField, 1, 1);
		}
		animationFrameLay->setColumnStretch(0, 0);
		animationFrameLay->setColumnStretch(1, 0);
		animationFrameLay->setColumnStretch(2, 1);
		animationFrameLay->setRowStretch(0, 0);
		animationFrameLay->setRowStretch(1, 0);
		animationFrameLay->setRowStretch(2, 1);
		animationBox->setLayout(animationFrameLay);
		stackedWidget->addWidget(animationBox);

		//--- Preview --------------------------
		QWidget *previewBox = new QWidget(this);
		QGridLayout *previewLayout = new QGridLayout();
		previewLayout->setMargin(15);
		previewLayout->setHorizontalSpacing(15);
		previewLayout->setVerticalSpacing(10);
		{
			previewLayout->addWidget(new QLabel(tr(""Blank Frames:"")), 0, 0, Qt::AlignRight | Qt::AlignVCenter);
			previewLayout->addWidget(m_blanksCount, 0, 1);

			previewLayout->addWidget(new QLabel(tr(""Blank Frames Color:"")), 1, 0, Qt::AlignRight | Qt::AlignVCenter);
			previewLayout->addWidget(m_blankColor, 1, 1, 1, 2);

			previewLayout->addWidget(rewindAfterPlaybackCB, 2, 0, 1, 3, Qt::AlignLeft | Qt::AlignVCenter);
			previewLayout->addWidget(displayInNewFlipBookCB, 3, 0, 1, 3, Qt::AlignLeft | Qt::AlignVCenter);
			previewLayout->addWidget(fitToFlipbookCB, 4, 0, 1, 3, Qt::AlignLeft | Qt::AlignVCenter);
		}
		previewLayout->setColumnStretch(0, 0);
		previewLayout->setColumnStretch(1, 0);
		previewLayout->setColumnStretch(2, 1);
		previewLayout->setRowStretch(0, 0);
		previewLayout->setRowStretch(1, 0);
		previewLayout->setRowStretch(2, 0);
		previewLayout->setRowStretch(3, 0);
		previewLayout->setRowStretch(4, 0);
		previewLayout->setRowStretch(5, 1);
		previewBox->setLayout(previewLayout);
		stackedWidget->addWidget(previewBox);

		//--- Onion Skin --------------------------
		QWidget *onionBox = new QWidget(this);
		QVBoxLayout *onionLay = new QVBoxLayout();
		onionLay->setMargin(15);
		onionLay->setSpacing(10);
		{
			onionLay->addWidget(m_onionSkinVisibility, 0, Qt::AlignLeft | Qt::AlignVCenter);
			QGridLayout *onionColorLay = new QGridLayout();
			{
				onionColorLay->addWidget(new QLabel(tr(""Paper Thickness:"")), 0, 0, Qt::AlignRight | Qt::AlignVCenter);
				onionColorLay->addWidget(m_onionPaperThickness, 0, 1);

				onionColorLay->addWidget(new QLabel(tr(""Previous  Frames Correction:"")), 1, 0, Qt::AlignRight | Qt::AlignVCenter);
				onionColorLay->addWidget(m_backOnionColor, 1, 1);

				onionColorLay->addWidget(new QLabel(tr(""Following Frames Correction:"")), 2, 0, Qt::AlignRight | Qt::AlignVCenter);
				onionColorLay->addWidget(m_frontOnionColor, 2, 1);
			}
			onionColorLay->setColumnStretch(0, 0);
			onionColorLay->setColumnStretch(1, 0);
			onionColorLay->setColumnStretch(2, 1);
			onionLay->addLayout(onionColorLay, 0);

			onionLay->addWidget(m_inksOnly, 0, Qt::AlignLeft | Qt::AlignVCenter);

			onionLay->addStretch(1);
		}
		onionBox->setLayout(onionLay);
		stackedWidget->addWidget(onionBox);

		//--- Transparency Check --------------------------
		QWidget *tcBox = new QWidget(this);
		QGridLayout *tcLay = new QGridLayout();
		tcLay->setMargin(15);
		tcLay->setHorizontalSpacing(10);
		tcLay->setVerticalSpacing(10);
		{
			tcLay->addWidget(new QLabel(tr(""Ink Color on White Bg:"")), 0, 0, Qt::AlignRight);
			tcLay->addWidget(m_transpCheckInkColor, 0, 1);

			tcLay->addWidget(new QLabel(tr(""Ink Color on Black Bg:"")), 1, 0, Qt::AlignRight);
			tcLay->addWidget(m_transpCheckBgColor, 1, 1);

			tcLay->addWidget(new QLabel(tr(""Paint Color:"")), 2, 0, Qt::AlignRight);
			tcLay->addWidget(m_transpCheckPaintColor, 2, 1);
		}
		tcLay->setColumnStretch(0, 0);
		tcLay->setColumnStretch(1, 0);
		tcLay->setColumnStretch(2, 1);
		tcLay->setRowStretch(0, 0);
		tcLay->setRowStretch(1, 0);
		tcLay->setRowStretch(2, 0);
		tcLay->setRowStretch(3, 1);
		tcBox->setLayout(tcLay);
		stackedWidget->addWidget(tcBox);

		//--- Version Control --------------------------
		QWidget *versionControlBox = new QWidget(this);
		QVBoxLayout *vcLay = new QVBoxLayout();
		vcLay->setMargin(15);
		vcLay->setSpacing(10);
		{
			vcLay->addWidget(m_enableVersionControl, 0, Qt::AlignLeft | Qt::AlignVCenter);
			vcLay->addWidget(autoRefreshFolderContentsCB, 0, Qt::AlignLeft | Qt::AlignVCenter);

			vcLay->addStretch(1);

			vcLay->addWidget(note_version, 0);
		}
		versionControlBox->setLayout(vcLay);
		stackedWidget->addWidget(versionControlBox);

		mainLayout->addWidget(stackedWidget, 1);
	}
	setLayout(mainLayout);

	/*---- signal-slot connections -----*/

	bool ret = true;
	ret = ret && connect(categoryList, SIGNAL(currentRowChanged(int)), stackedWidget, SLOT(setCurrentIndex(int)));

	//--- General ----------------------
	ret = ret && connect(useDefaultViewerCB, SIGNAL(stateChanged(int)), this, SLOT(onDefaultViewerChanged(int)));
	ret = ret && connect(minimizeRasterMemoryCB, SIGNAL(stateChanged(int)), this, SLOT(onRasterOptimizedMemoryChanged(int)));
	ret = ret && connect(autoSaveCB, SIGNAL(stateChanged(int)), SLOT(onAutoSaveChanged(int)));
	ret = ret && connect(m_minuteFld, SIGNAL(editingFinished()), SLOT(onMinuteChanged()));
	ret = ret && connect(m_cellsDragBehaviour, SIGNAL(currentIndexChanged(int)), SLOT(onDragCellsBehaviourChanged(int)));
	ret = ret && connect(m_undoMemorySize, SIGNAL(editingFinished()), SLOT(onUndoMemorySizeChanged()));
	ret = ret && connect(m_levelsBackup, SIGNAL(stateChanged(int)), SLOT(onLevelsBackupChanged(int)));
	ret = ret && connect(sceneNumberingCB, SIGNAL(stateChanged(int)), SLOT(onSceneNumberingChanged(int)));
	ret = ret && connect(m_chunkSizeFld, SIGNAL(editingFinished()), this, SLOT(onChunkSizeChanged()));

	//--- Interface ----------------------
	ret = ret && connect(styleSheetType, SIGNAL(currentIndexChanged(int)), SLOT(onStyleSheetTypeChanged(int)));
	ret = ret && connect(unitOm, SIGNAL(currentIndexChanged(int)), SLOT(onUnitChanged(int)));
	ret = ret && connect(cameraUnitOm, SIGNAL(currentIndexChanged(int)), SLOT(onCameraUnitChanged(int)));
	ret = ret && connect(openFlipbookAfterCB, SIGNAL(stateChanged(int)), this, SLOT(onViewGeneratedMovieChanged(int)));
	ret = ret && connect(m_iconSizeLx, SIGNAL(editingFinished()), SLOT(onIconSizeChanged()));
	ret = ret && connect(m_iconSizeLy, SIGNAL(editingFinished()), SLOT(onIconSizeChanged()));
	ret = ret && connect(m_viewShrink, SIGNAL(editingFinished()), SLOT(onViewValuesChanged()));
	ret = ret && connect(m_viewStep, SIGNAL(editingFinished()), SLOT(onViewValuesChanged()));
	if (languageList.size() > 1)
		ret = ret && connect(languageType, SIGNAL(currentIndexChanged(int)), SLOT(onLanguageTypeChanged(int)));
	ret = ret && connect(moveCurrentFrameCB, SIGNAL(stateChanged(int)), this, SLOT(onMoveCurrentFrameChanged(int)));
	ret = ret && connect(viewerZoomCenterComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(onViewerZoomCenterChanged(int)));
	ret = ret && connect(replaceAfterSaveLevelAsCB, SIGNAL(stateChanged(int)), this, SLOT(onReplaceAfterSaveLevelAsChanged(int)));
	ret = ret && connect(showRasterImageDarkenBlendedInViewerCB, SIGNAL(stateChanged(int)), this, SLOT(onShowRasterImageDarkenBlendedInViewerChanged(int)));
	ret = ret && connect(showShowFrameNumberWithLettersCB, SIGNAL(stateChanged(int)), this, SLOT(onShowFrameNumberWithLettersChanged(int)));
	//Viewer BG color
	ret = ret && connect(m_viewerBgColorFld, SIGNAL(colorChanged(const TPixel32 &, bool)), this, SLOT(setViewerBgColor(const TPixel32 &, bool)));
	//Preview BG color
	ret = ret && connect(m_previewBgColorFld, SIGNAL(colorChanged(const TPixel32 &, bool)), this, SLOT(setPreviewBgColor(const TPixel32 &, bool)));
	//bg chessboard colors
	ret = ret && connect(m_chessboardColor1Fld, SIGNAL(colorChanged(const TPixel32 &, bool)), this, SLOT(setChessboardColor1(const TPixel32 &, bool)));
	ret = ret && connect(m_chessboardColor2Fld, SIGNAL(colorChanged(const TPixel32 &, bool)), this, SLOT(setChessboardColor2(const TPixel32 &, bool)));
	//Column Icon
	ret = ret && connect(m_columnIconOm, SIGNAL(currentIndexChanged(const QString &)), this, SLOT(onColumnIconChange(const QString &)));
	ret = ret && connect(actualPixelOnSceneModeCB, SIGNAL(stateChanged(int)), SLOT(onActualPixelOnSceneModeChanged(int)));
	ret = ret && connect(levelNameOnEachMarkerCB, SIGNAL(stateChanged(int)), SLOT(onLevelNameOnEachMarkerChanged(int)));

	//--- Visualization ---------------------
	ret = ret && connect(show0ThickLinesCB, SIGNAL(stateChanged(int)), this, SLOT(onShow0ThickLinesChanged(int)));
	ret = ret && connect(regionAntialiasCB, SIGNAL(stateChanged(int)), this, SLOT(onRegionAntialiasChanged(int)));

	//--- Loading ----------------------
	ret = ret && connect(exposeLoadedLevelsCB, SIGNAL(stateChanged(int)), this, SLOT(onAutoExposeChanged(int)));
	ret = ret && connect(initialLoadTlvCachingBehaviorComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(onInitialLoadTlvCachingBehaviorChanged(int)));
	ret = ret && connect(createSubfolderCB, SIGNAL(stateChanged(int)), this, SLOT(onSubsceneFolderChanged(int)));
	ret = ret && connect(removeSceneNumberFromLoadedLevelNameCB, SIGNAL(stateChanged(int)), this, SLOT(onRemoveSceneNumberFromLoadedLevelNameChanged(int)));
	ret = ret && connect(m_addLevelFormat, SIGNAL(clicked()), SLOT(onAddLevelFormat()));
	ret = ret && connect(m_removeLevelFormat, SIGNAL(clicked()), SLOT(onRemoveLevelFormat()));
	ret = ret && connect(m_editLevelFormat, SIGNAL(clicked()), SLOT(onEditLevelFormat()));
	ret = ret && connect(paletteTypeForRasterColorModelComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(onPaletteTypeForRasterColorModelChanged(int)));

	//--- Drawing ----------------------
	ret = ret && connect(keepOriginalCleanedUpCB, SIGNAL(stateChanged(int)), this, SLOT(onSaveUnpaintedInCleanupChanged(int)));
	ret = ret && connect(multiLayerStylePickerCB, SIGNAL(stateChanged(int)), this, SLOT(onMultiLayerStylePickerChanged(int)));
	ret = ret && connect(useSaveboxToLimitFillingOpCB, SIGNAL(stateChanged(int)), this, SLOT(onGetFillOnlySavebox(int)));
#ifndef BRAVO
	ret = ret && connect(m_defScanLevelType, SIGNAL(currentIndexChanged(const QString &)), SLOT(onScanLevelTypeChanged(const QString &)));
#endif
	ret = ret && connect(minimizeSaveboxAfterEditingCB, SIGNAL(stateChanged(int)), this, SLOT(onMinimizeSaveboxAfterEditing(int)));
	ret = ret && connect(m_defLevelType, SIGNAL(currentIndexChanged(int)), SLOT(onDefLevelTypeChanged(int)));
	ret = ret && connect(m_autocreationType, SIGNAL(currentIndexChanged(int)), SLOT(onAutocreationTypeChanged(int)));
	ret = ret && connect(m_defLevelWidth, SIGNAL(valueChanged()), SLOT(onDefLevelParameterChanged()));
	ret = ret && connect(m_defLevelHeight, SIGNAL(valueChanged()), SLOT(onDefLevelParameterChanged()));
	ret = ret && connect(m_defLevelDpi, SIGNAL(valueChanged()), SLOT(onDefLevelParameterChanged()));

	//--- Xsheet ----------------------
	ret = ret && connect(xsheetAutopanDuringPlaybackCB, SIGNAL(stateChanged(int)), this, SLOT(onXsheetAutopanChanged(int)));
	ret = ret && connect(ignoreAlphaonColumn1CB, SIGNAL(stateChanged(int)), this, SLOT(onIgnoreAlphaonColumn1Changed(int)));
	ret = ret && connect(m_xsheetStep, SIGNAL(editingFinished()), SLOT(onXsheetStepChanged()));
	ret = ret && connect(m_cellsDragBehaviour, SIGNAL(currentIndexChanged(int)), SLOT(onDragCellsBehaviourChanged(int)));
	ret = ret && connect(showKeyframesOnCellAreaCB, SIGNAL(stateChanged(int)), this, SLOT(onShowKeyframesOnCellAreaChanged(int)));

	//--- Animation ----------------------
	ret = ret && connect(m_keyframeType, SIGNAL(currentIndexChanged(int)), SLOT(onKeyframeTypeChanged(int)));
	ret = ret && connect(m_animationStepField, SIGNAL(editingFinished()), SLOT(onAnimationStepChanged()));

	//--- Preview ----------------------
	ret = ret && connect(m_blanksCount, SIGNAL(editingFinished()), SLOT(onBlankCountChanged()));
	ret = ret && connect(m_blankColor, SIGNAL(colorChanged(const TPixel32 &, bool)), SLOT(onBlankColorChanged(const TPixel32 &, bool)));
	ret = ret && connect(rewindAfterPlaybackCB, SIGNAL(stateChanged(int)), this, SLOT(onRewindAfterPlayback(int)));
	ret = ret && connect(displayInNewFlipBookCB, SIGNAL(stateChanged(int)), this, SLOT(onPreviewAlwaysOpenNewFlip(int)));
	ret = ret && connect(fitToFlipbookCB, SIGNAL(stateChanged(int)), this, SLOT(onFitToFlipbook(int)));

	//--- Onion Skin ----------------------
	ret = ret && connect(m_frontOnionColor, SIGNAL(colorChanged(const TPixel32 &, bool)), SLOT(onOnionDataChanged(const TPixel32 &, bool)));
	ret = ret && connect(m_backOnionColor, SIGNAL(colorChanged(const TPixel32 &, bool)), SLOT(onOnionDataChanged(const TPixel32 &, bool)));
	ret = ret && connect(m_inksOnly, SIGNAL(stateChanged(int)), SLOT(onOnionDataChanged(int)));
	ret = ret && connect(m_onionSkinVisibility, SIGNAL(stateChanged(int)), SLOT(onOnionSkinVisibilityChanged(int)));
	ret = ret && connect(m_onionPaperThickness, SIGNAL(editingFinished()), SLOT(onOnionPaperThicknessChanged()));

	//--- Transparency Check ----------------------
	ret = ret && connect(m_transpCheckBgColor, SIGNAL(colorChanged(const TPixel32 &, bool)), SLOT(onTranspCheckDataChanged(const TPixel32 &, bool)));
	ret = ret && connect(m_transpCheckInkColor, SIGNAL(colorChanged(const TPixel32 &, bool)), SLOT(onTranspCheckDataChanged(const TPixel32 &, bool)));
	ret = ret && connect(m_transpCheckPaintColor, SIGNAL(colorChanged(const TPixel32 &, bool)), SLOT(onTranspCheckDataChanged(const TPixel32 &, bool)));

	//--- Version Control ----------------------
	ret = ret && connect(m_enableVersionControl, SIGNAL(stateChanged(int)), SLOT(onSVNEnabledChanged(int)));
	ret = ret && connect(autoRefreshFolderContentsCB, SIGNAL(stateChanged(int)), SLOT(onAutomaticSVNRefreshChanged(int)));

	assert(ret);
}

//-----------------------------------------------------------------------------

OpenPopupCommandHandler<PreferencesPopup> openPreferencesPopup(MI_Preferences);
",16191,True,3499.2443198772617,median
"/*********************************************************************
* Software License Agreement (BSD License)
*
*  Copyright (c) 2009, Willow Garage, Inc.
*  All rights reserved.
*
*  Redistribution and use in source and binary forms, with or without
*  modification, are permitted provided that the following conditions
*  are met:
*
*   * 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 Willow Garage 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.
*********************************************************************/

/** Authors: Ethan Rublee, Vincent Rabaud, Gary Bradski */

#include <rtabmap/core/Features2d.h>
#include <rtabmap/utilite/UConversion.h>
#include <rtabmap/utilite/UStl.h>

#include ""opencv2/features2d/features2d.hpp""
#include ""opencv2/imgproc/imgproc.hpp""
#include ""opencv2/imgproc/imgproc_c.h""
#include <algorithm>
#include <iterator>

#include ""Orb.h""
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

using namespace cv;

namespace rtabmap
{

const float HARRIS_K = 0.04f;

/**
 * Function that computes the Harris responses in a
 * blockSize x blockSize patch at given points in an image
 */
static void
HarrisResponses(const Mat& img, std::vector<KeyPoint>& pts, int blockSize, float harris_k)
{
    CV_Assert( img.type() == CV_8UC1 && blockSize*blockSize <= 2048 );

    size_t ptidx, ptsize = pts.size();

    const uchar* ptr00 = img.ptr<uchar>();
    int step = (int)(img.step/img.elemSize1());
    int r = blockSize/2;

    float scale = (1 << 2) * blockSize * 255.0f;
    scale = 1.0f / scale;
    float scale_sq_sq = scale * scale * scale * scale;

    AutoBuffer<int> ofsbuf(blockSize*blockSize);
    int* ofs = ofsbuf;
    for( int i = 0; i < blockSize; i++ )
        for( int j = 0; j < blockSize; j++ )
            ofs[i*blockSize + j] = (int)(i*step + j);

    for( ptidx = 0; ptidx < ptsize; ptidx++ )
    {
        int x0 = cvRound(pts[ptidx].pt.x - r);
        int y0 = cvRound(pts[ptidx].pt.y - r);

        const uchar* ptr0 = ptr00 + y0*step + x0;
        int a = 0, b = 0, c = 0;

        for( int k = 0; k < blockSize*blockSize; k++ )
        {
            const uchar* ptr = ptr0 + ofs[k];
            int Ix = (ptr[1] - ptr[-1])*2 + (ptr[-step+1] - ptr[-step-1]) + (ptr[step+1] - ptr[step-1]);
            int Iy = (ptr[step] - ptr[-step])*2 + (ptr[step-1] - ptr[-step-1]) + (ptr[step+1] - ptr[-step+1]);
            a += Ix*Ix;
            b += Iy*Iy;
            c += Ix*Iy;
        }
        pts[ptidx].response = ((float)a * b - (float)c * c -
                               harris_k * ((float)a + b) * ((float)a + b))*scale_sq_sq;
    }
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

static float IC_Angle(const Mat& image, const int half_k, Point2f pt,
                      const std::vector<int> & u_max)
{
    int m_01 = 0, m_10 = 0;

    const uchar* center = &image.at<uchar> (cvRound(pt.y), cvRound(pt.x));

    // Treat the center line differently, v=0
    for (int u = -half_k; u <= half_k; ++u)
        m_10 += u * center[u];

    // Go line by line in the circular patch
    int step = (int)image.step1();
    for (int v = 1; v <= half_k; ++v)
    {
        // Proceed over the two lines
        int v_sum = 0;
        int d = u_max[v];
        for (int u = -d; u <= d; ++u)
        {
            int val_plus = center[u + v*step], val_minus = center[u - v*step];
            v_sum += (val_plus - val_minus);
            m_10 += u * (val_plus + val_minus);
        }
        m_01 += v * v_sum;
    }

    return fastAtan2((float)m_01, (float)m_10);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

static void computeOrbDescriptor(const KeyPoint& kpt,
                                 const Mat& img, const Point* pattern,
                                 uchar* desc, int dsize, int WTA_K)
{
    float angle = kpt.angle;
    //angle = cvFloor(angle/12)*12.f;
    angle *= (float)(CV_PI/180.f);
    float a = (float)cos(angle), b = (float)sin(angle);

    const uchar* center = &img.at<uchar>(cvRound(kpt.pt.y), cvRound(kpt.pt.x));
    int step = (int)img.step;

    float x, y;
    int ix, iy;
#if 1
    #define GET_VALUE(idx) \\
           (x = pattern[idx].x*a - pattern[idx].y*b, \\
            y = pattern[idx].x*b + pattern[idx].y*a, \\
            ix = cvRound(x), \\
            iy = cvRound(y), \\
            *(center + iy*step + ix) )
#else
    #define GET_VALUE(idx) \\
        (x = pattern[idx].x*a - pattern[idx].y*b, \\
        y = pattern[idx].x*b + pattern[idx].y*a, \\
        ix = cvFloor(x), iy = cvFloor(y), \\
        x -= ix, y -= iy, \\
        cvRound(center[iy*step + ix]*(1-x)*(1-y) + center[(iy+1)*step + ix]*(1-x)*y + \\
                center[iy*step + ix+1]*x*(1-y) + center[(iy+1)*step + ix+1]*x*y))
#endif

    if( WTA_K == 2 )
    {
        for (int i = 0; i < dsize; ++i, pattern += 16)
        {
            int t0, t1, val;
            t0 = GET_VALUE(0); t1 = GET_VALUE(1);
            val = t0 < t1;
            t0 = GET_VALUE(2); t1 = GET_VALUE(3);
            val |= (t0 < t1) << 1;
            t0 = GET_VALUE(4); t1 = GET_VALUE(5);
            val |= (t0 < t1) << 2;
            t0 = GET_VALUE(6); t1 = GET_VALUE(7);
            val |= (t0 < t1) << 3;
            t0 = GET_VALUE(8); t1 = GET_VALUE(9);
            val |= (t0 < t1) << 4;
            t0 = GET_VALUE(10); t1 = GET_VALUE(11);
            val |= (t0 < t1) << 5;
            t0 = GET_VALUE(12); t1 = GET_VALUE(13);
            val |= (t0 < t1) << 6;
            t0 = GET_VALUE(14); t1 = GET_VALUE(15);
            val |= (t0 < t1) << 7;

            desc[i] = (uchar)val;
        }
    }
    else if( WTA_K == 3 )
    {
        for (int i = 0; i < dsize; ++i, pattern += 12)
        {
            int t0, t1, t2, val;
            t0 = GET_VALUE(0); t1 = GET_VALUE(1); t2 = GET_VALUE(2);
            val = t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0);

            t0 = GET_VALUE(3); t1 = GET_VALUE(4); t2 = GET_VALUE(5);
            val |= (t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0)) << 2;

            t0 = GET_VALUE(6); t1 = GET_VALUE(7); t2 = GET_VALUE(8);
            val |= (t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0)) << 4;

            t0 = GET_VALUE(9); t1 = GET_VALUE(10); t2 = GET_VALUE(11);
            val |= (t2 > t1 ? (t2 > t0 ? 2 : 0) : (t1 > t0)) << 6;

            desc[i] = (uchar)val;
        }
    }
    else if( WTA_K == 4 )
    {
        for (int i = 0; i < dsize; ++i, pattern += 16)
        {
            int t0, t1, t2, t3, u, v, k, val;
            t0 = GET_VALUE(0); t1 = GET_VALUE(1);
            t2 = GET_VALUE(2); t3 = GET_VALUE(3);
            u = 0, v = 2;
            if( t1 > t0 ) t0 = t1, u = 1;
            if( t3 > t2 ) t2 = t3, v = 3;
            k = t0 > t2 ? u : v;
            val = k;

            t0 = GET_VALUE(4); t1 = GET_VALUE(5);
            t2 = GET_VALUE(6); t3 = GET_VALUE(7);
            u = 0, v = 2;
            if( t1 > t0 ) t0 = t1, u = 1;
            if( t3 > t2 ) t2 = t3, v = 3;
            k = t0 > t2 ? u : v;
            val |= k << 2;

            t0 = GET_VALUE(8); t1 = GET_VALUE(9);
            t2 = GET_VALUE(10); t3 = GET_VALUE(11);
            u = 0, v = 2;
            if( t1 > t0 ) t0 = t1, u = 1;
            if( t3 > t2 ) t2 = t3, v = 3;
            k = t0 > t2 ? u : v;
            val |= k << 4;

            t0 = GET_VALUE(12); t1 = GET_VALUE(13);
            t2 = GET_VALUE(14); t3 = GET_VALUE(15);
            u = 0, v = 2;
            if( t1 > t0 ) t0 = t1, u = 1;
            if( t3 > t2 ) t2 = t3, v = 3;
            k = t0 > t2 ? u : v;
            val |= k << 6;

            desc[i] = (uchar)val;
        }
    }
    else
        CV_Error( CV_StsBadSize, ""Wrong WTA_K. It can be only 2, 3 or 4."" );

    #undef GET_VALUE
}


static void initializeOrbPattern( const Point* pattern0, std::vector<Point>& pattern, int ntuples, int tupleSize, int poolSize )
{
    RNG rng(0x12345678);
    int i, k, k1;
    pattern.resize(ntuples*tupleSize);

    for( i = 0; i < ntuples; i++ )
    {
        for( k = 0; k < tupleSize; k++ )
        {
            for(;;)
            {
                int idx = rng.uniform(0, poolSize);
                Point pt = pattern0[idx];
                for( k1 = 0; k1 < k; k1++ )
                    if( pattern[tupleSize*i + k1] == pt )
                        break;
                if( k1 == k )
                {
                    pattern[tupleSize*i + k] = pt;
                    break;
                }
            }
        }
    }
}

static int bit_pattern_31_[256*4] =
{
    8,-3, 9,5/*mean (0), correlation (0)*/,
    4,2, 7,-12/*mean (1.12461e-05), correlation (0.0437584)*/,
    -11,9, -8,2/*mean (3.37382e-05), correlation (0.0617409)*/,
    7,-12, 12,-13/*mean (5.62303e-05), correlation (0.0636977)*/,
    2,-13, 2,12/*mean (0.000134953), correlation (0.085099)*/,
    1,-7, 1,6/*mean (0.000528565), correlation (0.0857175)*/,
    -2,-10, -2,-4/*mean (0.0188821), correlation (0.0985774)*/,
    -13,-13, -11,-8/*mean (0.0363135), correlation (0.0899616)*/,
    -13,-3, -12,-9/*mean (0.121806), correlation (0.099849)*/,
    10,4, 11,9/*mean (0.122065), correlation (0.093285)*/,
    -13,-8, -8,-9/*mean (0.162787), correlation (0.0942748)*/,
    -11,7, -9,12/*mean (0.21561), correlation (0.0974438)*/,
    7,7, 12,6/*mean (0.160583), correlation (0.130064)*/,
    -4,-5, -3,0/*mean (0.228171), correlation (0.132998)*/,
    -13,2, -12,-3/*mean (0.00997526), correlation (0.145926)*/,
    -9,0, -7,5/*mean (0.198234), correlation (0.143636)*/,
    12,-6, 12,-1/*mean (0.0676226), correlation (0.16689)*/,
    -3,6, -2,12/*mean (0.166847), correlation (0.171682)*/,
    -6,-13, -4,-8/*mean (0.101215), correlation (0.179716)*/,
    11,-13, 12,-8/*mean (0.200641), correlation (0.192279)*/,
    4,7, 5,1/*mean (0.205106), correlation (0.186848)*/,
    5,-3, 10,-3/*mean (0.234908), correlation (0.192319)*/,
    3,-7, 6,12/*mean (0.0709964), correlation (0.210872)*/,
    -8,-7, -6,-2/*mean (0.0939834), correlation (0.212589)*/,
    -2,11, -1,-10/*mean (0.127778), correlation (0.20866)*/,
    -13,12, -8,10/*mean (0.14783), correlation (0.206356)*/,
    -7,3, -5,-3/*mean (0.182141), correlation (0.198942)*/,
    -4,2, -3,7/*mean (0.188237), correlation (0.21384)*/,
    -10,-12, -6,11/*mean (0.14865), correlation (0.23571)*/,
    5,-12, 6,-7/*mean (0.222312), correlation (0.23324)*/,
    5,-6, 7,-1/*mean (0.229082), correlation (0.23389)*/,
    1,0, 4,-5/*mean (0.241577), correlation (0.215286)*/,
    9,11, 11,-13/*mean (0.00338507), correlation (0.251373)*/,
    4,7, 4,12/*mean (0.131005), correlation (0.257622)*/,
    2,-1, 4,4/*mean (0.152755), correlation (0.255205)*/,
    -4,-12, -2,7/*mean (0.182771), correlation (0.244867)*/,
    -8,-5, -7,-10/*mean (0.186898), correlation (0.23901)*/,
    4,11, 9,12/*mean (0.226226), correlation (0.258255)*/,
    0,-8, 1,-13/*mean (0.0897886), correlation (0.274827)*/,
    -13,-2, -8,2/*mean (0.148774), correlation (0.28065)*/,
    -3,-2, -2,3/*mean (0.153048), correlation (0.283063)*/,
    -6,9, -4,-9/*mean (0.169523), correlation (0.278248)*/,
    8,12, 10,7/*mean (0.225337), correlation (0.282851)*/,
    0,9, 1,3/*mean (0.226687), correlation (0.278734)*/,
    7,-5, 11,-10/*mean (0.00693882), correlation (0.305161)*/,
    -13,-6, -11,0/*mean (0.0227283), correlation (0.300181)*/,
    10,7, 12,1/*mean (0.125517), correlation (0.31089)*/,
    -6,-3, -6,12/*mean (0.131748), correlation (0.312779)*/,
    10,-9, 12,-4/*mean (0.144827), correlation (0.292797)*/,
    -13,8, -8,-12/*mean (0.149202), correlation (0.308918)*/,
    -13,0, -8,-4/*mean (0.160909), correlation (0.310013)*/,
    3,3, 7,8/*mean (0.177755), correlation (0.309394)*/,
    5,7, 10,-7/*mean (0.212337), correlation (0.310315)*/,
    -1,7, 1,-12/*mean (0.214429), correlation (0.311933)*/,
    3,-10, 5,6/*mean (0.235807), correlation (0.313104)*/,
    2,-4, 3,-10/*mean (0.00494827), correlation (0.344948)*/,
    -13,0, -13,5/*mean (0.0549145), correlation (0.344675)*/,
    -13,-7, -12,12/*mean (0.103385), correlation (0.342715)*/,
    -13,3, -11,8/*mean (0.134222), correlation (0.322922)*/,
    -7,12, -4,7/*mean (0.153284), correlation (0.337061)*/,
    6,-10, 12,8/*mean (0.154881), correlation (0.329257)*/,
    -9,-1, -7,-6/*mean (0.200967), correlation (0.33312)*/,
    -2,-5, 0,12/*mean (0.201518), correlation (0.340635)*/,
    -12,5, -7,5/*mean (0.207805), correlation (0.335631)*/,
    3,-10, 8,-13/*mean (0.224438), correlation (0.34504)*/,
    -7,-7, -4,5/*mean (0.239361), correlation (0.338053)*/,
    -3,-2, -1,-7/*mean (0.240744), correlation (0.344322)*/,
    2,9, 5,-11/*mean (0.242949), correlation (0.34145)*/,
    -11,-13, -5,-13/*mean (0.244028), correlation (0.336861)*/,
    -1,6, 0,-1/*mean (0.247571), correlation (0.343684)*/,
    5,-3, 5,2/*mean (0.000697256), correlation (0.357265)*/,
    -4,-13, -4,12/*mean (0.00213675), correlation (0.373827)*/,
    -9,-6, -9,6/*mean (0.0126856), correlation (0.373938)*/,
    -12,-10, -8,-4/*mean (0.0152497), correlation (0.364237)*/,
    10,2, 12,-3/*mean (0.0299933), correlation (0.345292)*/,
    7,12, 12,12/*mean (0.0307242), correlation (0.366299)*/,
    -7,-13, -6,5/*mean (0.0534975), correlation (0.368357)*/,
    -4,9, -3,4/*mean (0.099865), correlation (0.372276)*/,
    7,-1, 12,2/*mean (0.117083), correlation (0.364529)*/,
    -7,6, -5,1/*mean (0.126125), correlation (0.369606)*/,
    -13,11, -12,5/*mean (0.130364), correlation (0.358502)*/,
    -3,7, -2,-6/*mean (0.131691), correlation (0.375531)*/,
    7,-8, 12,-7/*mean (0.160166), correlation (0.379508)*/,
    -13,-7, -11,-12/*mean (0.167848), correlation (0.353343)*/,
    1,-3, 12,12/*mean (0.183378), correlation (0.371916)*/,
    2,-6, 3,0/*mean (0.228711), correlation (0.371761)*/,
    -4,3, -2,-13/*mean (0.247211), correlation (0.364063)*/,
    -1,-13, 1,9/*mean (0.249325), correlation (0.378139)*/,
    7,1, 8,-6/*mean (0.000652272), correlation (0.411682)*/,
    1,-1, 3,12/*mean (0.00248538), correlation (0.392988)*/,
    9,1, 12,6/*mean (0.0206815), correlation (0.386106)*/,
    -1,-9, -1,3/*mean (0.0364485), correlation (0.410752)*/,
    -13,-13, -10,5/*mean (0.0376068), correlation (0.398374)*/,
    7,7, 10,12/*mean (0.0424202), correlation (0.405663)*/,
    12,-5, 12,9/*mean (0.0942645), correlation (0.410422)*/,
    6,3, 7,11/*mean (0.1074), correlation (0.413224)*/,
    5,-13, 6,10/*mean (0.109256), correlation (0.408646)*/,
    2,-12, 2,3/*mean (0.131691), correlation (0.416076)*/,
    3,8, 4,-6/*mean (0.165081), correlation (0.417569)*/,
    2,6, 12,-13/*mean (0.171874), correlation (0.408471)*/,
    9,-12, 10,3/*mean (0.175146), correlation (0.41296)*/,
    -8,4, -7,9/*mean (0.183682), correlation (0.402956)*/,
    -11,12, -4,-6/*mean (0.184672), correlation (0.416125)*/,
    1,12, 2,-8/*mean (0.191487), correlation (0.386696)*/,
    6,-9, 7,-4/*mean (0.192668), correlation (0.394771)*/,
    2,3, 3,-2/*mean (0.200157), correlation (0.408303)*/,
    6,3, 11,0/*mean (0.204588), correlation (0.411762)*/,
    3,-3, 8,-8/*mean (0.205904), correlation (0.416294)*/,
    7,8, 9,3/*mean (0.213237), correlation (0.409306)*/,
    -11,-5, -6,-4/*mean (0.243444), correlation (0.395069)*/,
    -10,11, -5,10/*mean (0.247672), correlation (0.413392)*/,
    -5,-8, -3,12/*mean (0.24774), correlation (0.411416)*/,
    -10,5, -9,0/*mean (0.00213675), correlation (0.454003)*/,
    8,-1, 12,-6/*mean (0.0293635), correlation (0.455368)*/,
    4,-6, 6,-11/*mean (0.0404971), correlation (0.457393)*/,
    -10,12, -8,7/*mean (0.0481107), correlation (0.448364)*/,
    4,-2, 6,7/*mean (0.050641), correlation (0.455019)*/,
    -2,0, -2,12/*mean (0.0525978), correlation (0.44338)*/,
    -5,-8, -5,2/*mean (0.0629667), correlation (0.457096)*/,
    7,-6, 10,12/*mean (0.0653846), correlation (0.445623)*/,
    -9,-13, -8,-8/*mean (0.0858749), correlation (0.449789)*/,
    -5,-13, -5,-2/*mean (0.122402), correlation (0.450201)*/,
    8,-8, 9,-13/*mean (0.125416), correlation (0.453224)*/,
    -9,-11, -9,0/*mean (0.130128), correlation (0.458724)*/,
    1,-8, 1,-2/*mean (0.132467), correlation (0.440133)*/,
    7,-4, 9,1/*mean (0.132692), correlation (0.454)*/,
    -2,1, -1,-4/*mean (0.135695), correlation (0.455739)*/,
    11,-6, 12,-11/*mean (0.142904), correlation (0.446114)*/,
    -12,-9, -6,4/*mean (0.146165), correlation (0.451473)*/,
    3,7, 7,12/*mean (0.147627), correlation (0.456643)*/,
    5,5, 10,8/*mean (0.152901), correlation (0.455036)*/,
    0,-4, 2,8/*mean (0.167083), correlation (0.459315)*/,
    -9,12, -5,-13/*mean (0.173234), correlation (0.454706)*/,
    0,7, 2,12/*mean (0.18312), correlation (0.433855)*/,
    -1,2, 1,7/*mean (0.185504), correlation (0.443838)*/,
    5,11, 7,-9/*mean (0.185706), correlation (0.451123)*/,
    3,5, 6,-8/*mean (0.188968), correlation (0.455808)*/,
    -13,-4, -8,9/*mean (0.191667), correlation (0.459128)*/,
    -5,9, -3,-3/*mean (0.193196), correlation (0.458364)*/,
    -4,-7, -3,-12/*mean (0.196536), correlation (0.455782)*/,
    6,5, 8,0/*mean (0.1972), correlation (0.450481)*/,
    -7,6, -6,12/*mean (0.199438), correlation (0.458156)*/,
    -13,6, -5,-2/*mean (0.211224), correlation (0.449548)*/,
    1,-10, 3,10/*mean (0.211718), correlation (0.440606)*/,
    4,1, 8,-4/*mean (0.213034), correlation (0.443177)*/,
    -2,-2, 2,-13/*mean (0.234334), correlation (0.455304)*/,
    2,-12, 12,12/*mean (0.235684), correlation (0.443436)*/,
    -2,-13, 0,-6/*mean (0.237674), correlation (0.452525)*/,
    4,1, 9,3/*mean (0.23962), correlation (0.444824)*/,
    -6,-10, -3,-5/*mean (0.248459), correlation (0.439621)*/,
    -3,-13, -1,1/*mean (0.249505), correlation (0.456666)*/,
    7,5, 12,-11/*mean (0.00119208), correlation (0.495466)*/,
    4,-2, 5,-7/*mean (0.00372245), correlation (0.484214)*/,
    -13,9, -9,-5/*mean (0.00741116), correlation (0.499854)*/,
    7,1, 8,6/*mean (0.0208952), correlation (0.499773)*/,
    7,-8, 7,6/*mean (0.0220085), correlation (0.501609)*/,
    -7,-4, -7,1/*mean (0.0233806), correlation (0.496568)*/,
    -8,11, -7,-8/*mean (0.0236505), correlation (0.489719)*/,
    -13,6, -12,-8/*mean (0.0268781), correlation (0.503487)*/,
    2,4, 3,9/*mean (0.0323324), correlation (0.501938)*/,
    10,-5, 12,3/*mean (0.0399235), correlation (0.494029)*/,
    -6,-5, -6,7/*mean (0.0420153), correlation (0.486579)*/,
    8,-3, 9,-8/*mean (0.0548021), correlation (0.484237)*/,
    2,-12, 2,8/*mean (0.0616622), correlation (0.496642)*/,
    -11,-2, -10,3/*mean (0.0627755), correlation (0.498563)*/,
    -12,-13, -7,-9/*mean (0.0829622), correlation (0.495491)*/,
    -11,0, -10,-5/*mean (0.0843342), correlation (0.487146)*/,
    5,-3, 11,8/*mean (0.0929937), correlation (0.502315)*/,
    -2,-13, -1,12/*mean (0.113327), correlation (0.48941)*/,
    -1,-8, 0,9/*mean (0.132119), correlation (0.467268)*/,
    -13,-11, -12,-5/*mean (0.136269), correlation (0.498771)*/,
    -10,-2, -10,11/*mean (0.142173), correlation (0.498714)*/,
    -3,9, -2,-13/*mean (0.144141), correlation (0.491973)*/,
    2,-3, 3,2/*mean (0.14892), correlation (0.500782)*/,
    -9,-13, -4,0/*mean (0.150371), correlation (0.498211)*/,
    -4,6, -3,-10/*mean (0.152159), correlation (0.495547)*/,
    -4,12, -2,-7/*mean (0.156152), correlation (0.496925)*/,
    -6,-11, -4,9/*mean (0.15749), correlation (0.499222)*/,
    6,-3, 6,11/*mean (0.159211), correlation (0.503821)*/,
    -13,11, -5,5/*mean (0.162427), correlation (0.501907)*/,
    11,11, 12,6/*mean (0.16652), correlation (0.497632)*/,
    7,-5, 12,-2/*mean (0.169141), correlation (0.484474)*/,
    -1,12, 0,7/*mean (0.169456), correlation (0.495339)*/,
    -4,-8, -3,-2/*mean (0.171457), correlation (0.487251)*/,
    -7,1, -6,7/*mean (0.175), correlation (0.500024)*/,
    -13,-12, -8,-13/*mean (0.175866), correlation (0.497523)*/,
    -7,-2, -6,-8/*mean (0.178273), correlation (0.501854)*/,
    -8,5, -6,-9/*mean (0.181107), correlation (0.494888)*/,
    -5,-1, -4,5/*mean (0.190227), correlation (0.482557)*/,
    -13,7, -8,10/*mean (0.196739), correlation (0.496503)*/,
    1,5, 5,-13/*mean (0.19973), correlation (0.499759)*/,
    1,0, 10,-13/*mean (0.204465), correlation (0.49873)*/,
    9,12, 10,-1/*mean (0.209334), correlation (0.49063)*/,
    5,-8, 10,-9/*mean (0.211134), correlation (0.503011)*/,
    -1,11, 1,-13/*mean (0.212), correlation (0.499414)*/,
    -9,-3, -6,2/*mean (0.212168), correlation (0.480739)*/,
    -1,-10, 1,12/*mean (0.212731), correlation (0.502523)*/,
    -13,1, -8,-10/*mean (0.21327), correlation (0.489786)*/,
    8,-11, 10,-6/*mean (0.214159), correlation (0.488246)*/,
    2,-13, 3,-6/*mean (0.216993), correlation (0.50287)*/,
    7,-13, 12,-9/*mean (0.223639), correlation (0.470502)*/,
    -10,-10, -5,-7/*mean (0.224089), correlation (0.500852)*/,
    -10,-8, -8,-13/*mean (0.228666), correlation (0.502629)*/,
    4,-6, 8,5/*mean (0.22906), correlation (0.498305)*/,
    3,12, 8,-13/*mean (0.233378), correlation (0.503825)*/,
    -4,2, -3,-3/*mean (0.234323), correlation (0.476692)*/,
    5,-13, 10,-12/*mean (0.236392), correlation (0.475462)*/,
    4,-13, 5,-1/*mean (0.236842), correlation (0.504132)*/,
    -9,9, -4,3/*mean (0.236977), correlation (0.497739)*/,
    0,3, 3,-9/*mean (0.24314), correlation (0.499398)*/,
    -12,1, -6,1/*mean (0.243297), correlation (0.489447)*/,
    3,2, 4,-8/*mean (0.00155196), correlation (0.553496)*/,
    -10,-10, -10,9/*mean (0.00239541), correlation (0.54297)*/,
    8,-13, 12,12/*mean (0.0034413), correlation (0.544361)*/,
    -8,-12, -6,-5/*mean (0.003565), correlation (0.551225)*/,
    2,2, 3,7/*mean (0.00835583), correlation (0.55285)*/,
    10,6, 11,-8/*mean (0.00885065), correlation (0.540913)*/,
    6,8, 8,-12/*mean (0.0101552), correlation (0.551085)*/,
    -7,10, -6,5/*mean (0.0102227), correlation (0.533635)*/,
    -3,-9, -3,9/*mean (0.0110211), correlation (0.543121)*/,
    -1,-13, -1,5/*mean (0.0113473), correlation (0.550173)*/,
    -3,-7, -3,4/*mean (0.0140913), correlation (0.554774)*/,
    -8,-2, -8,3/*mean (0.017049), correlation (0.55461)*/,
    4,2, 12,12/*mean (0.01778), correlation (0.546921)*/,
    2,-5, 3,11/*mean (0.0224022), correlation (0.549667)*/,
    6,-9, 11,-13/*mean (0.029161), correlation (0.546295)*/,
    3,-1, 7,12/*mean (0.0303081), correlation (0.548599)*/,
    11,-1, 12,4/*mean (0.0355151), correlation (0.523943)*/,
    -3,0, -3,6/*mean (0.0417904), correlation (0.543395)*/,
    4,-11, 4,12/*mean (0.0487292), correlation (0.542818)*/,
    2,-4, 2,1/*mean (0.0575124), correlation (0.554888)*/,
    -10,-6, -8,1/*mean (0.0594242), correlation (0.544026)*/,
    -13,7, -11,1/*mean (0.0597391), correlation (0.550524)*/,
    -13,12, -11,-13/*mean (0.0608974), correlation (0.55383)*/,
    6,0, 11,-13/*mean (0.065126), correlation (0.552006)*/,
    0,-1, 1,4/*mean (0.074224), correlation (0.546372)*/,
    -13,3, -9,-2/*mean (0.0808592), correlation (0.554875)*/,
    -9,8, -6,-3/*mean (0.0883378), correlation (0.551178)*/,
    -13,-6, -8,-2/*mean (0.0901035), correlation (0.548446)*/,
    5,-9, 8,10/*mean (0.0949843), correlation (0.554694)*/,
    2,7, 3,-9/*mean (0.0994152), correlation (0.550979)*/,
    -1,-6, -1,-1/*mean (0.10045), correlation (0.552714)*/,
    9,5, 11,-2/*mean (0.100686), correlation (0.552594)*/,
    11,-3, 12,-8/*mean (0.101091), correlation (0.532394)*/,
    3,0, 3,5/*mean (0.101147), correlation (0.525576)*/,
    -1,4, 0,10/*mean (0.105263), correlation (0.531498)*/,
    3,-6, 4,5/*mean (0.110785), correlation (0.540491)*/,
    -13,0, -10,5/*mean (0.112798), correlation (0.536582)*/,
    5,8, 12,11/*mean (0.114181), correlation (0.555793)*/,
    8,9, 9,-6/*mean (0.117431), correlation (0.553763)*/,
    7,-4, 8,-12/*mean (0.118522), correlation (0.553452)*/,
    -10,4, -10,9/*mean (0.12094), correlation (0.554785)*/,
    7,3, 12,4/*mean (0.122582), correlation (0.555825)*/,
    9,-7, 10,-2/*mean (0.124978), correlation (0.549846)*/,
    7,0, 12,-2/*mean (0.127002), correlation (0.537452)*/,
    -1,-6, 0,-11/*mean (0.127148), correlation (0.547401)*/
};


static void makeRandomPattern(int patchSize, Point* pattern, int npoints)
{
    RNG rng(0x34985739); // we always start with a fixed seed,
                         // to make patterns the same on each run
    for( int i = 0; i < npoints; i++ )
    {
        pattern[i].x = rng.uniform(-patchSize/2, patchSize/2+1);
        pattern[i].y = rng.uniform(-patchSize/2, patchSize/2+1);
    }
}


static inline float getScale(int level, int firstLevel, double scaleFactor)
{
    return (float)std::pow(scaleFactor, (double)(level - firstLevel));
}

/** Constructor
 * @param detector_params parameters to use
 */
CV_ORB::CV_ORB(int _nfeatures, float _scaleFactor, int _nlevels, int _edgeThreshold,
         int _firstLevel, int _WTA_K, int _scoreType, int _patchSize, const ParametersMap & _fastParameters) :
    nfeatures(_nfeatures), scaleFactor(_scaleFactor), nlevels(_nlevels),
    edgeThreshold(_edgeThreshold), firstLevel(_firstLevel), WTA_K(_WTA_K),
    scoreType(_scoreType), patchSize(_patchSize), fastParameters(_fastParameters)
{}


int CV_ORB::descriptorSize() const
{
    return kBytes;
}

int CV_ORB::descriptorType() const
{
    return CV_8U;
}

/** Compute the ORB features and descriptors on an image
 * @param img the image to compute the features and descriptors on
 * @param mask the mask to apply
 * @param keypoints the resulting keypoints
 */
void CV_ORB::operator()(InputArray image, InputArray mask, std::vector<KeyPoint>& keypoints) const
{
    (*this)(image, mask, keypoints, noArray(), false);
}


/** Compute the ORB keypoint orientations
 * @param image the image to compute the features and descriptors on
 * @param integral_image the integral image of the iamge (can be empty, but the computation will be slower)
 * @param scale the scale at which we compute the orientation
 * @param keypoints the resulting keypoints
 */
static void computeOrientation(const Mat& image, std::vector<KeyPoint>& keypoints,
                               int halfPatchSize, const std::vector<int>& umax)
{
    // Process each keypoint
    for (std::vector<KeyPoint>::iterator keypoint = keypoints.begin(),
         keypointEnd = keypoints.end(); keypoint != keypointEnd; ++keypoint)
    {
        keypoint->angle = IC_Angle(image, halfPatchSize, keypoint->pt, umax);
    }
}


/** Compute the ORB keypoints on an image
 * @param image_pyramid the image pyramid to compute the features and descriptors on
 * @param mask_pyramid the masks to apply at every level
 * @param keypoints the resulting keypoints, clustered per level
 */
static void computeKeyPoints(const std::vector<Mat>& imagePyramid,
                             const std::vector<Mat>& maskPyramid,
                             std::vector<std::vector<KeyPoint> >& allKeypoints,
                             int nfeatures, int firstLevel, double scaleFactor,
                             int edgeThreshold, int patchSize, int scoreType,
							 ParametersMap fastParameters)
{
    int nlevels = (int)imagePyramid.size();
    std::vector<int> nfeaturesPerLevel(nlevels);

    // fill the extractors and descriptors for the corresponding scales
    float factor = (float)(1.0 / scaleFactor);
    float ndesiredFeaturesPerScale = nfeatures*(1 - factor)/(1 - (float)pow((double)factor, (double)nlevels));

    int sumFeatures = 0;
    for( int level = 0; level < nlevels-1; level++ )
    {
        nfeaturesPerLevel[level] = cvRound(ndesiredFeaturesPerScale);
        sumFeatures += nfeaturesPerLevel[level];
        ndesiredFeaturesPerScale *= factor;
    }
    nfeaturesPerLevel[nlevels-1] = std::max(nfeatures - sumFeatures, 0);

    // Make sure we forget about what is too close to the boundary
    //edge_threshold_ = std::max(edge_threshold_, patch_size_/2 + kKernelWidth / 2 + 2);

    // pre-compute the end of a row in a circular patch
    int halfPatchSize = patchSize / 2;
    std::vector<int> umax(halfPatchSize + 2);

    int v, v0, vmax = cvFloor(halfPatchSize * sqrt(2.f) / 2 + 1);
    int vmin = cvCeil(halfPatchSize * sqrt(2.f) / 2);
    for (v = 0; v <= vmax; ++v)
        umax[v] = cvRound(sqrt((double)halfPatchSize * halfPatchSize - v * v));

    // Make sure we are symmetric
    for (v = halfPatchSize, v0 = 0; v >= vmin; --v)
    {
        while (umax[v0] == umax[v0 + 1])
            ++v0;
        umax[v] = v0;
        ++v0;
    }

    allKeypoints.resize(nlevels);

    for (int level = 0; level < nlevels; ++level)
    {
        int featuresNum = nfeaturesPerLevel[level];
        allKeypoints[level].reserve(featuresNum*2);

        std::vector<KeyPoint> & keypoints = allKeypoints[level];

        // Detect FAST features, maxFeatures is used by the GridAdaptor of FAST
        uInsert(fastParameters, ParametersPair(Parameters::kKpMaxFeatures(), uNumber2Str(scoreType == CV_ORB::HARRIS_SCORE?2*featuresNum:featuresNum)));
     	FAST fast(fastParameters);
        keypoints = fast.generateKeypoints(imagePyramid[level], maskPyramid[level]);

        // Remove keypoints very close to the border
        KeyPointsFilter::runByImageBorder(keypoints, imagePyramid[level].size(), edgeThreshold);

        if( scoreType == CV_ORB::HARRIS_SCORE )
        {
            // Keep more points than necessary as FAST does not give amazing corners
            KeyPointsFilter::retainBest(keypoints, 2 * featuresNum);

            // Compute the Harris cornerness (better scoring than FAST)
            HarrisResponses(imagePyramid[level], keypoints, 7, HARRIS_K);
        }

        //cull to the final desired level, using the new Harris scores or the original FAST scores.
        KeyPointsFilter::retainBest(keypoints, featuresNum);

        float sf = getScale(level, firstLevel, scaleFactor);

        // Set the level of the coordinates
        for (std::vector<KeyPoint>::iterator keypoint = keypoints.begin(),
             keypointEnd = keypoints.end(); keypoint != keypointEnd; ++keypoint)
        {
            keypoint->octave = level;
            keypoint->size = patchSize*sf;
        }

        computeOrientation(imagePyramid[level], keypoints, halfPatchSize, umax);
    }
}


/** Compute the ORB decriptors
 * @param image the image to compute the features and descriptors on
 * @param integral_image the integral image of the image (can be empty, but the computation will be slower)
 * @param level the scale at which we compute the orientation
 * @param keypoints the keypoints to use
 * @param descriptors the resulting descriptors
 */
static void computeDescriptors(const Mat& image, std::vector<KeyPoint>& keypoints, Mat& descriptors,
                               const std::vector<Point>& pattern, int dsize, int WTA_K)
{
    //convert to grayscale if more than one color
    CV_Assert(image.type() == CV_8UC1);
    //create the descriptor mat, keypoints.size() rows, BYTES cols
    descriptors = Mat::zeros((int)keypoints.size(), dsize, CV_8UC1);

    for (size_t i = 0; i < keypoints.size(); i++)
        computeOrbDescriptor(keypoints[i], image, &pattern[0], descriptors.ptr((int)i), dsize, WTA_K);
}


/** Compute the ORB features and descriptors on an image
 * @param img the image to compute the features and descriptors on
 * @param mask the mask to apply
 * @param keypoints the resulting keypoints
 * @param descriptors the resulting descriptors
 * @param do_keypoints if true, the keypoints are computed, otherwise used as an input
 * @param do_descriptors if true, also computes the descriptors
 */
void CV_ORB::operator()( InputArray _image, InputArray _mask, std::vector<KeyPoint>& _keypoints,
                      OutputArray _descriptors, bool useProvidedKeypoints) const
{
    CV_Assert(patchSize >= 2);

    bool do_keypoints = !useProvidedKeypoints;
    bool do_descriptors = _descriptors.needed();

    if( (!do_keypoints && !do_descriptors) || _image.empty() )
        return;

    //ROI handling
    const int HARRIS_BLOCK_SIZE = 9;
    int halfPatchSize = patchSize / 2;
    int border = std::max(edgeThreshold, std::max(halfPatchSize, HARRIS_BLOCK_SIZE/2))+1;

    Mat image = _image.getMat(), mask = _mask.getMat();
    if( image.type() != CV_8UC1 )
        cvtColor(_image, image, CV_BGR2GRAY);

    int levelsNum = this->nlevels;

    if( !do_keypoints )
    {
        // if we have pre-computed keypoints, they may use more levels than it is set in parameters
        // !!!TODO!!! implement more correct method, independent from the used keypoint detector.
        // Namely, the detector should provide correct size of each keypoint. Based on the keypoint size
        // and the algorithm used (i.e. BRIEF, running on 31x31 patches) we should compute the approximate
        // scale-factor that we need to apply. Then we should cluster all the computed scale-factors and
        // for each cluster compute the corresponding image.
        //
        // In short, ultimately the descriptor should
        // ignore octave parameter and deal only with the keypoint size.
        levelsNum = 0;
        for( size_t i = 0; i < _keypoints.size(); i++ )
            levelsNum = std::max(levelsNum, std::max(_keypoints[i].octave, 0));
        levelsNum++;
    }

    // Pre-compute the scale pyramids
    std::vector<Mat> imagePyramid(levelsNum), maskPyramid(levelsNum);
    for (int level = 0; level < levelsNum; ++level)
    {
        float scale = 1/getScale(level, firstLevel, scaleFactor);
        Size sz(cvRound(image.cols*scale), cvRound(image.rows*scale));
        Size wholeSize(sz.width + border*2, sz.height + border*2);
        Mat temp(wholeSize, image.type()), masktemp;
        imagePyramid[level] = temp(Rect(border, border, sz.width, sz.height));

        if( !mask.empty() )
        {
            masktemp = Mat(wholeSize, mask.type());
            maskPyramid[level] = masktemp(Rect(border, border, sz.width, sz.height));
        }

        // Compute the resized image
        if( level != firstLevel )
        {
            if( level < firstLevel )
            {
                resize(image, imagePyramid[level], sz, 0, 0, INTER_LINEAR);
                if (!mask.empty())
                    resize(mask, maskPyramid[level], sz, 0, 0, INTER_LINEAR);
            }
            else
            {
                resize(imagePyramid[level-1], imagePyramid[level], sz, 0, 0, INTER_LINEAR);
                if (!mask.empty())
                {
                    resize(maskPyramid[level-1], maskPyramid[level], sz, 0, 0, INTER_LINEAR);
                    threshold(maskPyramid[level], maskPyramid[level], 254, 0, THRESH_TOZERO);
                }
            }

            copyMakeBorder(imagePyramid[level], temp, border, border, border, border,
                           BORDER_REFLECT_101+BORDER_ISOLATED);
            if (!mask.empty())
                copyMakeBorder(maskPyramid[level], masktemp, border, border, border, border,
                               BORDER_CONSTANT+BORDER_ISOLATED);
        }
        else
        {
            copyMakeBorder(image, temp, border, border, border, border,
                           BORDER_REFLECT_101);
            if( !mask.empty() )
                copyMakeBorder(mask, masktemp, border, border, border, border,
                               BORDER_CONSTANT+BORDER_ISOLATED);
        }
    }

    // Pre-compute the keypoints (we keep the best over all scales, so this has to be done beforehand
    std::vector < std::vector<KeyPoint> > allKeypoints;
    if( do_keypoints )
    {
        // Get keypoints, those will be far enough from the border that no check will be required for the descriptor
        computeKeyPoints(imagePyramid, maskPyramid, allKeypoints,
                         nfeatures, firstLevel, scaleFactor,
                         edgeThreshold, patchSize, scoreType,
						 fastParameters);

        // make sure we have the right number of keypoints keypoints
        /*vector<KeyPoint> temp;

        for (int level = 0; level < n_levels; ++level)
        {
            vector<KeyPoint>& keypoints = all_keypoints[level];
            temp.insert(temp.end(), keypoints.begin(), keypoints.end());
            keypoints.clear();
        }

        KeyPoint::retainBest(temp, n_features_);

        for (vector<KeyPoint>::iterator keypoint = temp.begin(),
             keypoint_end = temp.end(); keypoint != keypoint_end; ++keypoint)
            all_keypoints[keypoint->octave].push_back(*keypoint);*/
    }
    else
    {
        // Remove keypoints very close to the border
        KeyPointsFilter::runByImageBorder(_keypoints, image.size(), edgeThreshold);

        // Cluster the input keypoints depending on the level they were computed at
        allKeypoints.resize(levelsNum);
        for (std::vector<KeyPoint>::iterator keypoint = _keypoints.begin(),
             keypointEnd = _keypoints.end(); keypoint != keypointEnd; ++keypoint)
            allKeypoints[keypoint->octave].push_back(*keypoint);

        // Make sure we rescale the coordinates
        for (int level = 0; level < levelsNum; ++level)
        {
            if (level == firstLevel)
                continue;

            std::vector<KeyPoint> & keypoints = allKeypoints[level];
            float scale = 1/getScale(level, firstLevel, scaleFactor);
            for (std::vector<KeyPoint>::iterator keypoint = keypoints.begin(),
                 keypointEnd = keypoints.end(); keypoint != keypointEnd; ++keypoint)
                keypoint->pt *= scale;
        }
    }

    Mat descriptors;
    std::vector<Point> pattern;

    if( do_descriptors )
    {
        int nkeypoints = 0;
        for (int level = 0; level < levelsNum; ++level)
            nkeypoints += (int)allKeypoints[level].size();
        if( nkeypoints == 0 )
            _descriptors.release();
        else
        {
            _descriptors.create(nkeypoints, descriptorSize(), CV_8U);
            descriptors = _descriptors.getMat();
        }

        const int npoints = 512;
        Point patternbuf[npoints];
        const Point* pattern0 = (const Point*)bit_pattern_31_;

        if( patchSize != 31 )
        {
            pattern0 = patternbuf;
            makeRandomPattern(patchSize, patternbuf, npoints);
        }

        CV_Assert( WTA_K == 2 || WTA_K == 3 || WTA_K == 4 );

        if( WTA_K == 2 )
            std::copy(pattern0, pattern0 + npoints, std::back_inserter(pattern));
        else
        {
            int ntuples = descriptorSize()*4;
            initializeOrbPattern(pattern0, pattern, ntuples, WTA_K, npoints);
        }
    }

    _keypoints.clear();
    int offset = 0;
    for (int level = 0; level < levelsNum; ++level)
    {
        // Get the features and compute their orientation
    	std::vector<KeyPoint>& keypoints = allKeypoints[level];
        int nkeypoints = (int)keypoints.size();

        // Compute the descriptors
        if (do_descriptors)
        {
            Mat desc;
            if (!descriptors.empty())
            {
                desc = descriptors.rowRange(offset, offset + nkeypoints);
            }

            offset += nkeypoints;
            // preprocess the resized image
            Mat& workingMat = imagePyramid[level];
            //boxFilter(working_mat, working_mat, working_mat.depth(), Size(5,5), Point(-1,-1), true, BORDER_REFLECT_101);
            GaussianBlur(workingMat, workingMat, Size(7, 7), 2, 2, BORDER_REFLECT_101);
            computeDescriptors(workingMat, keypoints, desc, pattern, descriptorSize(), WTA_K);
        }

        // Copy to the output data
        if (level != firstLevel)
        {
            float scale = getScale(level, firstLevel, scaleFactor);
            for (std::vector<KeyPoint>::iterator keypoint = keypoints.begin(),
                 keypointEnd = keypoints.end(); keypoint != keypointEnd; ++keypoint)
                keypoint->pt *= scale;
        }
        // And add the keypoints to the output
        _keypoints.insert(_keypoints.end(), keypoints.begin(), keypoints.end());
    }
}

void CV_ORB::detectImpl( const Mat& image, std::vector<KeyPoint>& keypoints, const Mat& mask) const
{
    (*this)(image, mask, keypoints, noArray(), false);
}

void CV_ORB::computeImpl( const Mat& image, std::vector<KeyPoint>& keypoints, Mat& descriptors) const
{
    (*this)(image, Mat(), keypoints, descriptors, true);
}

}
",16239,True,3670.577462862887,median
"class ZCL_4_CH03_ABAP_EXAMPLES definition
  public
  create public .

public section.
protected section.
private section.

  methods L03_01_QUERY_WITHOUT_VALUE  ##RELAX.
  methods L03_02_QUERY_WITH_VALUE  ##RELAX.
  methods L03_03_VALUE_TO_FILL_ITAB  ##RELAX.
  methods L03_04_FILLING_ITAB_HARDCODE  ##RELAX.
  methods L03_05_FILLING_ITAB_VIA_FOR  ##RELAX.
  methods L03_06_SHORT_LIVED_VARIABLES  ##RELAX.
  methods L03_07_BASIC_ENUMERATION  ##RELAX.
  methods L03_08_NON_INTEGER_ENUMERATION  ##RELAX.
  methods L03_09_STRUCTURED_ENUMERATION  ##RELAX.
  methods L03_10_ALPHA_INPUT_OUTPUT   ##RELAX
    raising
      /IWBEP/CX_MGW_BUSI_EXCEPTION .
  methods L03_11_ALPHA_FOMATTING_OPTION   ##RELAX
    raising
      /IWBEP/CX_MGW_BUSI_EXCEPTION .
  methods L03_12_METHOD_GUESS_DATA_TYPE  ##RELAX.
  methods L03_13_METHOD_INLINE_DECS  ##RELAX.
  methods L03_14_METHOD_CALL_W_HELPER   ##RELAX
    raising
      CX_AMC_ERROR .
  methods L03_15_METHOD_CALL_W_CONV   ##RELAX
    raising
      CX_AMC_ERROR .
  methods L03_16_TYPE_REF_TO_OLD
    importing
      !IS_CTX type /BOBF/S_FRW_CTX_DET
      !IO_MODIFY type ref to /BOBF/IF_FRW_MODIFY .
  methods L03_17_ABAP_TRUE .
  methods L03_18_NO_ABAP_TRUE .
  methods L03_19_IF_WRONG_CHECK .
  methods L03_20_BOOLC
    returning
      value(RT_RESULT) type BAPIRET2_TAB .
  methods L03_21_NEGATIVE_TESTING .
  methods L03_22_XSDBOOL .
  methods L03_23_CASE_STATEMENT
    importing
      !ID_EDIT_MODE type LRM_CRUD_MODE .
  methods L03_24_SWITCH_STATEMENT
    importing
      !ID_EDIT_MODE type LRM_CRUD_MODE .
  methods L03_26_CASE_STATEMENT
    changing
      !CS_MONSTER_HEADER type Z4SC_MONSTER_HEADER .
  methods L03_27_COND_STATEMENT
    changing
      !CS_MONSTER_HEADER type Z4SC_MONSTER_HEADER .
  methods L03_28_COND_STATEMENT_UPDATED
    changing
      !CS_MONSTER_HEADER type Z4SC_MONSTER_HEADER_EX .
  methods L03_29_INTERNAL_TABLES_WA .
  methods L03_30_INTERNAL_TABLES_FS .
  methods L03_31_READING_TABLE_LINE_OLD .
  methods L03_32_READING_TABLE_LINE_NEW .
  methods L03_33_READING_TABLE_OPTIONAL .
  methods L03_34_COPYING_ITABS_OLD .
  methods L03_35_COPYING_ITABS_NEW .
  methods L03_36_COPY_TO_HASHED_ITAB
    importing
      !ID_ORDER_NUMBER type Z4DE_MONSTER_ORDER_NUMBER
      !ID_ITEM_NUMBER type Z4DE_MONSTER_ORDER_ITEM_NUMBER .
  methods L03_37_DEEP_STRUCTURE .
  methods L03_38_CORRESPONDING_OLD .
  methods L03_39_CORRESPONDING_OLD_V2 .
  methods L03_40_CORRESPONDING_NEW .
  methods L03_41_CORRESPONDING_DYNAMIC
    returning
      value(RS_BEST_BRAINS) type Z4ST_MONSTER_BEST_BRAINS .
  methods L03_42_GETTING_ROW_NO_OLD .
  methods L03_43_GETTING_ROW_NO_NEW .
  methods L03_44_GETTING_ROW_NO_NEWER .
  methods L03_45_ITAB_ROW_EXISTS_OLD .
  methods L03_46_ITAB_ROW_EXISTS_NEW .
  methods L03_47_ITAB_ROW_EXISTS_NEWER .
  methods L03_48_REDUCE .
  methods L03_49_GROUP_BY .
  methods L03_50_TABLE_EXTRACTION_OLD .
  methods L03_51_TABLE_EXTRACTION_NEW .
  methods L03_52_FAE_DATABASE .
  methods L03_53_FAE_ITAB .
  methods L03_54_VIRTUAL_SORTING .
  methods L03_55_VIRTUAL_SORTING_PART_2 .
  methods L03_56_QUERY_DDIC_NO_CAST .
  methods L03_57_QUERY_DDIC_WITH_CAST .
  methods L03_58_FIND_A_SUBCLASS_OLD
    importing
      !IO_SALV_ADAPTER type ref to CL_SALV_ADAPTER
    returning
      value(RO_ALV_GRID) type ref to CL_GUI_ALV_GRID .
  methods L03_59_FIND_A_SUBCLASS_NEW
    importing
      !IO_SALV_ADAPTER type ref to CL_SALV_ADAPTER
    returning
      value(RO_ALV_GRID) type ref to CL_GUI_ALV_GRID .
  methods L03_60_FIND_A_SUBCLASS_NEW_V2
    importing
      !IO_SALV_ADAPTER type ref to CL_SALV_ADAPTER
    returning
      value(RO_ALV_GRID) type ref to CL_GUI_ALV_GRID .
  methods L03_61_FUNCTIONAL_METHOD_PLUS .
ENDCLASS.



CLASS ZCL_4_CH03_ABAP_EXAMPLES IMPLEMENTATION.


  METHOD l03_01_query_without_value.
*-----------------------------------------------------------------------------*
* Listing 03.01:  Database Query without VALUE
*-----------------------------------------------------------------------------*
* This is the BAD example so is not found anywhere in the monster applications
*-----------------------------------------------------------------------------*
    DATA:
      monster_type_range            TYPE ztt_bc_coseltab,
      monster_type_selection_option LIKE LINE OF monster_type_range.

    monster_type_selection_option-field  = 'EVILNESS'.
    monster_type_selection_option-option = 'EQ'.
    monster_type_selection_option-sign   = 'I'.
    monster_type_selection_option-low    = 'EVIL'.""Evil Monster
    APPEND monster_type_selection_option TO monster_type_range.

    monster_type_selection_option-field  = 'EVILNESS'.
    monster_type_selection_option-option = 'EQ'.
    monster_type_selection_option-sign   = 'I'.
    monster_type_selection_option-low    = 'VERY'.""Very Evil Monster
    APPEND monster_type_selection_option TO monster_type_range.

    DATA(monster)         = NEW zcl_4_monster_model( ).
    DATA(monster_headers) =
    monster->retrieve_headers_by_attribute( monster_type_range ).

  ENDMETHOD.


  METHOD l03_02_query_with_value.
*--------------------------------------------------------------------*
* Listing 03.02:  Database Query with VALUE
*--------------------------------------------------------------------*
    DATA(monster_headers) =
    NEW zcl_4_monster_model( )->retrieve_headers_by_attribute(
    VALUE ztt_bc_coseltab(
          ( field  = 'EVILNESS' )
          ( option = 'EQ' )
          ( sign   = 'I' )
          ( low    = 'EVIL' )     ""Evil Monster
          ( low    = 'VERY' ) ) ).""Very Evil Monster

  ENDMETHOD.


  METHOD l03_03_value_to_fill_itab.
*----------------------------------------------------------------------------*
* Listing 03.03:  Using VALUE to Fill Multiple Lines of Internal Table
*----------------------------------------------------------------------------*
* This is used in the unit tests for program ZALL_PAIRS
*----------------------------------------------------------------------------*
* You can see it in the LCL_MOCK_PERSISTENCY_LAYER class in method
* GET_DATA
*---------------------------------------------------------------------------*
    TYPES: BEGIN OF l_typ_configuration,
             variable_name  TYPE string,
             count          TYPE i,
             possible_value TYPE string,
           END OF   l_typ_configuration.

    TYPES: l_tt_configuration TYPE STANDARD TABLE OF l_typ_configuration
                              WITH KEY variable_name count.

    DATA(lt_configuration) = VALUE l_tt_configuration(
    ( variable_name = 'Monster Model'(002) count = 1 possible_value = 'BTNK' ) ""Bolts Through Neck
    ( variable_name = 'Monster Model'(002) count = 2 possible_value = 'KLKL' ) ""Killer Klown
    ( variable_name = 'Monster Model'(002) count = 3 possible_value = 'ISDD' ) ""Ice Skating Dead
    ( variable_name = 'Evilness'(003)      count = 1 possible_value = 'EVIL' )
    ( variable_name = 'Evilness'(003)      count = 2 possible_value = 'VERY' )
    ( variable_name = 'Brain Size'(004)    count = 1 possible_value = 'SMALL' )
    ( variable_name = 'Brain Size'(004)    count = 2 possible_value = 'MICRO' )
    ( variable_name = 'Scariness'(005)     count = 1 possible_value = 'NORM' )
    ( variable_name = 'Scariness'(005)     count = 2 possible_value = 'BANK' )
    ( variable_name = 'Usage'(006)         count = 1 possible_value = 'NORM' )
    ( variable_name = 'Usage'(006)         count = 2 possible_value = 'PLUM' )""IT'S THE PLUMBER!!!!
    ( variable_name = 'Color'(007)         count = 1 possible_value = 'BLUE' )
    ( variable_name = 'Color'(007)         count = 2 possible_value = 'GREEN' ) ).

  ENDMETHOD.


  METHOD l03_04_filling_itab_hardcode.
*--------------------------------------------------------------------*
* Listing 03.04:  Fill Internal Table using Hard Coding
*--------------------------------------------------------------------*
* This is the bad example so is not used in any monster applications
*--------------------------------------------------------------------*
    DATA(table_of_monsters) = VALUE z4tt_monster_header(
   ( name = 'JIMMY' monster_number = 1 )
   ( name = 'ROLF ' monster_number = 2 ) ).

  ENDMETHOD.


  METHOD l03_05_filling_itab_via_for.
*--------------------------------------------------------------------*
* Listing 03.05:  Filling Internal Tables from Other Tables
*--------------------------------------------------------------------*
    SELECT *
    FROM z4t_monster_head
    INTO TABLE @DATA(all_monsters).

    DATA(neurotic_monsters) = VALUE z4tt_monster_header(
     FOR monster_details IN all_monsters WHERE ( sanity_percentage < 20 )
         ( name           = monster_details-name
           monster_number = monster_details-monster_number ) ).

  ENDMETHOD.


  METHOD l03_06_short_lived_variables.
*--------------------------------------------------------------------*
* Listing 03.06:  Creating Short-Lived Variables
*--------------------------------------------------------------------*
    SELECT *
          FROM z4t_monster_head
          INTO TABLE @DATA(all_monsters).

    DATA(iterator) = NEW lcl_weapon_iterator( ).

    DO lines( all_monsters[] ) TIMES.
      DATA(arming_description) = CONV string(
        LET weapon_name  = iterator->get_next_weapon( )
            monster_name = all_monsters[ sy-index ]-name
            date_string  =
           |{ sy-datum } DATE = USER|
        IN |{ 'Monster'(018) } { monster_name } { 'was issued a'(019) } | &&
           |{ weapon_name } { 'on'(020) } { date_string }| ).
      MESSAGE arming_description TYPE 'I'.
    ENDDO.

  ENDMETHOD.


  METHOD l03_07_basic_enumeration.
*--------------------------------------------------------------------*
* Listing 03.07:  Basic Enumeration
*--------------------------------------------------------------------*
    TYPES: BEGIN OF ENUM monster_brain_size,
             normal,
             small,
             micro,
           END OF ENUM monster_brain_size.

    DATA: brain_size TYPE monster_brain_size.

  ENDMETHOD.


  METHOD l03_08_non_integer_enumeration.
*--------------------------------------------------------------------*
* Listing 03.08:  Non-Integer Enumeration
*--------------------------------------------------------------------*
    TYPES:
      brain_size TYPE c LENGTH 8,
      BEGIN OF ENUM monster_brain_size BASE TYPE brain_size,
        normal VALUE IS INITIAL,
        small  VALUE 'SMALL',
        micro  VALUE 'MICRO',
      END OF ENUM monster_brain_size.

    DATA(brain_size) = NEW monster_brain_size( small ).

  ENDMETHOD.


  METHOD l03_09_structured_enumeration.
*--------------------------------------------------------------------*
* Listing 03.09:  Enumeration with Structure
*--------------------------------------------------------------------*
    TYPES: BEGIN OF ENUM monster_brain_size
             STRUCTURE brain_sizes,
             normal,
             small,
             micro,
           END OF ENUM monster_brain_size
           STRUCTURE brain_sizes.

    DATA(brain_size) = brain_sizes-small.

* One Haunted Castle can be found at 53 degrees Latitude
  ENDMETHOD.


  METHOD l03_10_alpha_input_output.
*-----------------------------------------------------------------------------*
* Listing 03.10:  Removing and Adding Leading Zeroes by Function Call
*-----------------------------------------------------------------------------*
* This is the bad example so is not found anywhere in the monster applications
*-----------------------------------------------------------------------------*

    DATA: monster_number TYPE z4de_monster_number VALUE '0000000001'.

    DATA(segw_service) = NEW zcl_z_4_monster_dpc_ext( ).

    DATA(message_container) =
    segw_service->/iwbep/if_mgw_conv_srv_runtime~get_message_container( ).

    ""Remove Leading Zeroes ready for Output to User
    CALL FUNCTION 'CONVERSION_EXIT_ALPHA_OUTPUT'
      EXPORTING
        input  = monster_number
      IMPORTING
        output = monster_number.

    message_container->add_message_text_only(
    EXPORTING
    iv_msg_type = /iwbep/if_message_container=>gcs_message_type-error
    iv_msg_text = |Monster No { monster_number } | &&
                  |does not want to be deleted| ).

    ""Add back leading zeroes in case you need to read database
    CALL FUNCTION 'CONVERSION_EXIT_ALPHA_INPUT'
      EXPORTING
        input  = monster_number
      IMPORTING
        output = monster_number.

    RAISE EXCEPTION NEW /iwbep/cx_mgw_busi_exception(
        message_container = message_container ).

  ENDMETHOD.


  METHOD l03_11_alpha_fomatting_option.
*-----------------------------------------------------------------------*
* Listing 03.11:  Removing Leading Zeroes via Formatting Option
*-----------------------------------------------------------------------*
* Used in method MONSTERS_DELETE_ENTITY of Class ZCL_Z_4_MONSTER_DPC_EXT
*-----------------------------------------------------------------------*

    DATA: monster_number TYPE z4de_monster_number VALUE '0000000001'.

    DATA(segw_service) = NEW zcl_z_4_monster_dpc_ext( ).

    DATA(message_container) =
    segw_service->/iwbep/if_mgw_conv_srv_runtime~get_message_container( ).

    message_container->add_message_text_only(
    EXPORTING
    iv_msg_type = /iwbep/if_message_container=>gcs_message_type-error
    iv_msg_text = |Monster No { monster_number ALPHA = OUT } does not want to be deleted| ).

    RAISE EXCEPTION NEW /iwbep/cx_mgw_busi_exception(
        message_container = message_container ).

  ENDMETHOD.


  METHOD l03_12_method_guess_data_type.
*-------------------------------------------------------------------------------------*
* Listing 03.12:  Declaring Variables with (Hopefully) Same Types as Method Parameters
*-------------------------------------------------------------------------------------*
* This is the bad example so is not found anywhere in the monster applications
*-------------------------------------------------------------------------------------*
    DATA: changes_to_be_made  TYPE /bobf/t_frw_modification,
          actual_changes_made TYPE REF TO /bobf/if_tra_change,
          bottle_of_messages  TYPE REF TO /bobf/if_frw_message.

    DATA(bopf_service_manager) =
         /bobf/cl_tra_serv_mgr_factory=>get_service_manager(
         zif_4_monster_c=>sc_bo_key ).

    ""Change Data in Memory
    bopf_service_manager->modify(
    EXPORTING it_modification = changes_to_be_made
    IMPORTING eo_change       = actual_changes_made
              eo_message      = bottle_of_messages ).

  ENDMETHOD.


  METHOD l03_13_method_inline_decs.
*------------------------------------------------------------------------------*
* Listing 03.13:  Using Inline Declarations to Avoid Possible Type Mismatches
*------------------------------------------------------------------------------*
* This is used in method CHANGE_DATA_IN_MEMORY of Class ZCL_4_BC_BOPF_PL_HELPER
*------------------------------------------------------------------------------*
    DATA: changes_to_be_made TYPE /bobf/t_frw_modification.

    DATA(bopf_service_manager) =
         /bobf/cl_tra_serv_mgr_factory=>get_service_manager(
         zif_4_monster_c=>sc_bo_key ).

    ""Change Data in Memory
    bopf_service_manager->modify(
    EXPORTING it_modification = changes_to_be_made
    IMPORTING eo_change       = DATA(actual_changes_made)
              eo_message      = DATA(bottle_of_messages) ).

  ENDMETHOD.


  METHOD l03_14_method_call_w_helper.
*--------------------------------------------------------------------*
* Listing 03.14:  Moving Variable into Helper Variable
*--------------------------------------------------------------------*
* As an example the incoming Castle Number came from an external system
* in the form of NUMC4, but our method wants a CHAR60
*--------------------------------------------------------------------*
    DATA: helper        TYPE c LENGTH 60,
          castle_number TYPE n LENGTH 4 VALUE '0001'.

    helper = castle_number.

    ""In the below the EXTENSION_ID is CHAR60
    DATA(message_bottle) = CAST if_amc_message_producer_pcp(
        cl_amc_channel_manager=>create_message_producer(
          i_application_id       = 'ZAMC_4_MONSTERS'
          i_channel_id           = '/monsters'
          i_channel_extension_id = helper ) ).

  ENDMETHOD.


  METHOD l03_15_method_call_w_conv.
*---------------------------------------------------------------------------------*
* Listing 03.15:  Converting String with Constructor Variable
*---------------------------------------------------------------------------------*
* This is used in Program Z4_MONSTER_ATROCITY_DUE_LIST in method ALLOCATE_MONSTER
*---------------------------------------------------------------------------------*
    DATA: castle_number TYPE n LENGTH 4 VALUE '0001'.

    ""In the below the EXTENSION_ID is CHAR60
    DATA(message_bottle) = CAST if_amc_message_producer_pcp(
        cl_amc_channel_manager=>create_message_producer(
          i_application_id       = 'ZAMC_4_MONSTERS'
          i_channel_id           = '/monsters'
          i_channel_extension_id = CONV #( castle_number ) ) ).

  ENDMETHOD.


  METHOD l03_16_type_ref_to_old.
*--------------------------------------------------------------------*
* Listing 03.16:  Filling TYPE REF TO DATA Parameter
*--------------------------------------------------------------------*
* This is used in method /BOBF/IF_FRW_DETERMINATION~EXECUTE of
* class ZCL_4_D_MONSTERHEADER_TEXTS
*--------------------------------------------------------------------*
    DATA: bopf_monster_header_records TYPE z4tt_monster_header,
          header_record_reference     TYPE REF TO data.

    LOOP AT bopf_monster_header_records INTO DATA(bopf_monster_header_record).
      ""Before 7.4
      CREATE DATA header_record_reference LIKE bopf_monster_header_record.
      GET REFERENCE OF bopf_monster_header_record INTO header_record_reference.

      ""After 7.4
      header_record_reference = REF #( bopf_monster_header_record ).

      ""IS_DATA is type REF TO DATA
      io_modify->update(
        iv_node = is_ctx-node_key
        iv_key  = bopf_monster_header_record-key
        is_data = header_record_reference ).

    ENDLOOP.

  ENDMETHOD.


  METHOD l03_17_abap_true.
*--------------------------------------------------------------------*
* Listing 03.17:  ABAP_TRUE
*--------------------------------------------------------------------*
    DATA(monster) = zcl_4_monster_model=>get_instance( '0000000001' ).

    IF monster->is_scary( ) = abap_true.
      MESSAGE 'Oh No! Send for the Fire Brigade!'(008) TYPE 'I'.
    ENDIF.

  ENDMETHOD.


  METHOD l03_18_no_abap_true.
*--------------------------------------------------------------------*
* Listing 03.18:  Omitting ABAP_TRUE
*--------------------------------------------------------------------*
    DATA(monster) =
    zcl_4_monster_model=>get_instance( '0000000001' ).

    IF monster->is_scary( ).
      MESSAGE 'Oh No! Send for the Fire Brigade!'(008) TYPE 'I'.
    ENDIF.

* Each of the five suspect Monsters is a different COLOR
  ENDMETHOD.


  METHOD l03_19_if_wrong_check.
*--------------------------------------------------------------------*
* Listing 03.19:  IF Statement without Proper Check
*--------------------------------------------------------------------*
    DATA(monster) = NEW zcl_4_monster_model( ).

    IF monster->wants_to_blow_up_world( ).
      DATA(massive_atom_bomb) = NEW lcl_atom_bomb( ).
      massive_atom_bomb->explode( ).
    ENDIF.

  ENDMETHOD.


  METHOD l03_20_boolc.
*--------------------------------------------------------------------*
* Listing 03.20:  BOOLC
*--------------------------------------------------------------------*
* Do some groovy things
* Get some results

* Postconditions
    zcl_dbc=>ensure( that = 'A result table is returned'(009)
    which_is_true_if = boolc( rt_result[] IS NOT INITIAL ) ).

  ENDMETHOD.


  METHOD l03_21_negative_testing.
*--------------------------------------------------------------------*
* Listing 03.21:  Testing for Negative
*--------------------------------------------------------------------*
    DATA: empty_table TYPE STANDARD TABLE OF z4t_monster_head.

    IF boolc( empty_table[] IS NOT INITIAL ) = abap_false.
      WRITE:/ 'This table is empty'(010).
    ELSE.
      WRITE:/ 'This table is as full as full can be'(011).
    ENDIF.
    IF boolc( 1 = 2 ) = abap_false.
      WRITE:/ '1 does not equal 2'(012).
    ELSE.
      WRITE:/ '1 equals 2, and the world is made of snow'(013).
    ENDIF.

  ENDMETHOD.


  METHOD l03_22_xsdbool.
*--------------------------------------------------------------------*
* Listing 03.22:  Using XSDBOOL for Correct Logic Test Results
*--------------------------------------------------------------------*
    DATA: empty_table TYPE STANDARD TABLE OF z4t_monster_head.

    ""Then do the same using XSDBOOL.
    IF xsdbool( empty_table[] IS NOT INITIAL ) = abap_false.
      WRITE:/ 'This table is empty'(010).
    ELSE.
      WRITE:/ 'This table is as full as full can be'(011).
    ENDIF.
    IF xsdbool( 1 = 2 ) = abap_false.
      WRITE:/ '1 does not equal 2'(012).
    ELSE.
      WRITE:/ '1 equals 2, and the world is made of snow'(013).
    ENDIF.

  ENDMETHOD.


  METHOD l03_23_case_statement.
*--------------------------------------------------------------------*
* Listing 03.23:  Filling in Variable Using CASE Statement
*--------------------------------------------------------------------*
    ""Use adapter pattern to translate human readable CRUD standard to
    ""the BOPF equivalent
    DATA: bopf_edit_mode TYPE /bobf/conf_edit_mode.

    CASE id_edit_mode.
      WHEN 'R'.""Read
        bopf_edit_mode = /bobf/if_conf_c=>sc_edit_read_only.
      WHEN 'U'.""Update
        bopf_edit_mode = /bobf/if_conf_c=>sc_edit_exclusive.
      WHEN OTHERS.
        ""Unexpected Situation
        RAISE EXCEPTION TYPE zcx_4_monster_exceptions.
    ENDCASE.

  ENDMETHOD.


  METHOD L03_24_SWITCH_STATEMENT.
*--------------------------------------------------------------------*
* Listing 03.24:  Filling in Variable Using SWITCH Statement
*--------------------------------------------------------------------*
* Use adapter pattern to translate human readable CRUD
* standard values to the BOPF equivalent
    DATA(bopf_edit_mode) = SWITCH /bobf/conf_edit_mode( id_edit_mode
      WHEN 'R' THEN /bobf/if_conf_c=>sc_edit_read_only  ""Read
      WHEN 'U' THEN /bobf/if_conf_c=>sc_edit_exclusive  ""Update
      ELSE THROW zcx_4_monster_exceptions( ) ).           ""Unexpected Situation

  ENDMETHOD.


  METHOD l03_26_case_statement.
*--------------------------------------------------------------------*
* Listing 03.26:  CASE Statement to Evaluate Monster Sanity
*--------------------------------------------------------------------*
* This is the bad example so is not used in any monster applications
*--------------------------------------------------------------------*
    ""Fill the Sanity Description
    CASE cs_monster_header-sanity_percentage.
      WHEN 5.
        cs_monster_header-sanity_description = 'VERY SANE'.
      WHEN 4.
        cs_monster_header-sanity_description = 'SANE'.
      WHEN 3.
        cs_monster_header-sanity_description = 'SLIGHTLY MAD'.
      WHEN 2.
        cs_monster_header-sanity_description = 'VERY MAD'.
      WHEN 1.
        cs_monster_header-sanity_description = 'BONKERS'.
      WHEN OTHERS.
        cs_monster_header-sanity_description = 'RENAMES SAP PRODUCTS'.
    ENDCASE.

  ENDMETHOD.


  METHOD l03_27_cond_statement.
*--------------------------------------------------------------------*
* Listing 03.27:  Using COND Constructor Operator
*--------------------------------------------------------------------*
* Used in method DERIVE_HEADER_FIELDS of class ZCL_4_MONSTER_MODEL
*--------------------------------------------------------------------*
    ""Fill the Sanity Description
    cs_monster_header-sanity_description =
    COND #(
    WHEN cs_monster_header-sanity_percentage > 75 THEN 'VERY SANE'
    WHEN cs_monster_header-sanity_percentage > 50 THEN 'SANE'
    WHEN cs_monster_header-sanity_percentage > 25 THEN 'SLIGHTLY MAD'
    WHEN cs_monster_header-sanity_percentage > 12 THEN 'VERY MAD'
    WHEN cs_monster_header-sanity_percentage > 1  THEN 'BONKERS'
    ELSE 'RENAMES SAP PRODUCTS' ).

* In one Haunted Castle, in the Chapel, beside the Great Hall, the voices of two men are often heard talking.
* It is never possible to follow their words, and they stop talking if one makes serious efforts to trace them
  ENDMETHOD.


  METHOD l03_28_cond_statement_updated.
*--------------------------------------------------------------------*
* Listing 03.28:  COND Constructor Operator with Updated Logic
*--------------------------------------------------------------------*
    DATA: day TYPE char10.
    day = 'Tuesday'(014).""Lenny Henry!
    ""Fill the Sanity Description
    cs_monster_header-sanity_description =
    COND #(
    WHEN cs_monster_header-sanity_percentage = 5 THEN 'VERY SANE'
    WHEN cs_monster_header-sanity_percentage = 4 THEN 'SANE'
    WHEN cs_monster_header-sanity_percentage = 3 THEN 'SLIGHTLY MAD'
    WHEN cs_monster_header-sanity_percentage = 2 THEN 'VERY MAD'
    WHEN cs_monster_header-sanity_percentage = 1 AND
         day = 'Tuesday'(014)                    THEN 'HAVING AN OFF DAY'
    WHEN cs_monster_header-sanity_percentage = 1 THEN 'BONKERS'
    ELSE 'RENAMES SAP PRODUCTS' ).

  ENDMETHOD.


  METHOD l03_29_internal_tables_wa.
*--------------------------------------------------------------------*
* Listing 03.29:  Reading into Work Area and Looping through Table
*--------------------------------------------------------------------*
    DATA: table_of_monsters TYPE STANDARD TABLE OF z4t_monster_head.

    READ TABLE table_of_monsters
    WITH KEY color = 'RED'
    INTO DATA(red_monster_details).

    LOOP AT table_of_monsters INTO DATA(loopy_monster_details) ##into_ok.
    ENDLOOP.

  ENDMETHOD.


  METHOD l03_30_internal_tables_fs.
*--------------------------------------------------------------------*
* Listing 03.30:  Field Symbols for Work Area
*--------------------------------------------------------------------*
    DATA: table_of_monsters TYPE STANDARD TABLE OF z4t_monster_head.

    READ TABLE table_of_monsters
    WITH KEY color = 'RED'
    ASSIGNING FIELD-SYMBOL(<red_monster_details>).

    LOOP AT table_of_monsters ASSIGNING FIELD-SYMBOL(<loopy_monster_details>).
    ENDLOOP.

  ENDMETHOD.


  METHOD l03_31_reading_table_line_old.
*--------------------------------------------------------------------*
* Listing 03.31:  Reading Line from Internal Table before 7.4
*--------------------------------------------------------------------*
* Local Variables
    DATA: monster_name      TYPE z4de_monster_name VALUE 'JIMMY',
          table_of_monsters TYPE STANDARD TABLE OF z4t_monster_head,
          monster_details   LIKE LINE OF table_of_monsters,
          monster           TYPE REF TO zif_4_monster_model.

    READ TABLE table_of_monsters INTO monster_details
    WITH KEY name = monster_name.

    monster = zcl_4_monster_model=>get_instance( monster_details-monster_number ).

  ENDMETHOD.


  METHOD l03_32_reading_table_line_new.
*--------------------------------------------------------------------*
* Listing 03.32:  Reading Line from Internal Table after 7.40
*--------------------------------------------------------------------*
* Local Variables
    DATA: monster_name      TYPE z4de_monster_name VALUE 'HUBERT',
          table_of_monsters TYPE STANDARD TABLE OF z4t_monster_head.

    DATA(monster) = zcl_4_monster_model=>get_instance( table_of_monsters[ monster_name ]-monster_number  ).

  ENDMETHOD.


  METHOD l03_33_reading_table_optional.
*--------------------------------------------------------------------*
* Listing 03.33:  Reading Internal Table with OPTIONAL/DEFAULT
*--------------------------------------------------------------------*
* Local Variables
    DATA: monster_name      TYPE z4de_monster_name VALUE 'JIMMY',
          table_of_monsters TYPE STANDARD TABLE OF z4t_monster_head.

    DATA(message1) =
    |{ monster_name }{ '''s Monster Number is'(022) } | &&
    |{ VALUE #( table_of_monsters[ monster_name ]-monster_number OPTIONAL ) }|.

    DATA(message2) =
    |{ monster_name }{ '''s Monster Number is'(022) } | &&
    |{ VALUE #( table_of_monsters[ monster_name ]-monster_number DEFAULT '9999999999' ) }|.

  ENDMETHOD.


  METHOD l03_34_copying_itabs_old.
*---------------------------------------------------------------------*
* Listing 03.34:  Moving One Table to Another before 7.4
*---------------------------------------------------------------------*
* We are moving the GREEN monsters to a new BLUE monsters table
*---------------------------------------------------------------------*
* STRENGTH is the source field, EARLY AGE STRENGTH is the target field
*---------------------------------------------------------------------*
* Local Variables
    DATA: green_monsters TYPE STANDARD TABLE OF z4t_monster_head, ""Source
          blue_monsters  TYPE STANDARD TABLE OF z4t_monster_head. ""Target

    FIELD-SYMBOLS:
      <green_monsters> LIKE LINE OF green_monsters,
      <blue_monsters>  LIKE LINE OF blue_monsters.

    LOOP AT green_monsters ASSIGNING <green_monsters>.
      APPEND INITIAL LINE TO blue_monsters
      ASSIGNING <blue_monsters>.
      MOVE-CORRESPONDING <green_monsters> TO <blue_monsters>.
      ""We do not want to copy the evilness
      CLEAR <blue_monsters>-evilness.
      ""Move value to differently named field
      <blue_monsters>-early_age_strength =  <green_monsters>-strength.
    ENDLOOP.

  ENDMETHOD.


  METHOD l03_35_copying_itabs_new.
*---------------------------------------------------------------------*
* Listing 03.35:  Moving One Table to Another in 7.4
*---------------------------------------------------------------------*
* We are moving the GREEN monsters to a new BLUE monsters table
*---------------------------------------------------------------------*
* STRENGTH is the source field, EARLY AGE STRENGTH is the target field
*---------------------------------------------------------------------*
* Local Variables
    DATA: green_monsters TYPE STANDARD TABLE OF z4t_monster_head, ""Source
          blue_monsters  TYPE STANDARD TABLE OF z4t_monster_head. ""Target

    blue_monsters = CORRESPONDING #(
    green_monsters
    MAPPING early_age_strength = strength
    EXCEPT evilness ).

  ENDMETHOD.


  METHOD l03_36_copy_to_hashed_itab.
*--------------------------------------------------------------------*
* Listing 03.36: Moving Corresponding Fields to a HASHED Table
*--------------------------------------------------------------------*
* Local Variables
    DATA: monster_order_items TYPE HASHED TABLE OF z4t_order_items
                              WITH UNIQUE KEY order_number order_item.

    DATA(changed_item) = VALUE z4t_order_items(
    order_number     = '0000000001'
    order_item       = '000010'
    task_description = 'Do the Boogoloo' ).

    ""HASHED table
    READ TABLE monster_order_items ASSIGNING FIELD-SYMBOL(<order_item>)
    WITH TABLE KEY order_number = id_order_number
                   order_item   = id_item_number.

    IF sy-subrc = 0.
      ""Cannot over-write key fields of a Hashed Table
      <order_item> = CORRESPONDING #( BASE ( <order_item> ) changed_item
      EXCEPT order_number order_item ).
    ELSE.
      INSERT changed_item INTO TABLE monster_order_items.
    ENDIF.

* Each of the five suspect Monsters has a different HOBBY and each of those hobbies is really boring
  ENDMETHOD.


  METHOD l03_37_deep_structure.
*--------------------------------------------------------------------*
* Listing 03.37:  Deep Structure
*--------------------------------------------------------------------*
    TYPES: BEGIN OF l_typ_monsters,
             monster_number TYPE z4de_monster_number,
             monster_name   TYPE z4de_monster_name,
             t_items        TYPE z4tt_monster_items,
           END OF l_typ_monsters.
    DATA: monster_table TYPE STANDARD TABLE OF l_typ_monsters.

  ENDMETHOD.


  METHOD L03_38_CORRESPONDING_OLD.
*--------------------------------------------------------------------*
* Listing 03.38:  MOVE-CORRESPONDING Attempt
*--------------------------------------------------------------------*
    TYPES: BEGIN OF l_typ_european_monsters,
             monster_name      TYPE string,
             monster_iban_code TYPE string,
           END OF l_typ_european_monsters.

    TYPES: l_tt_european_monsters
    TYPE HASHED TABLE OF l_typ_european_monsters
    WITH UNIQUE KEY monster_name.

    DATA: iban_code_record TYPE l_typ_european_monsters.

    TYPES: BEGIN OF l_typ_european_results,
             laboratory TYPE string,
             t_result   TYPE l_tt_european_monsters,
           END OF l_typ_european_results.

    TYPES: l_tt_european_results
    TYPE STANDARD TABLE OF l_typ_european_results.

    DATA: european_result  TYPE l_typ_european_results,
          european_results TYPE l_tt_european_results.

    TYPES: BEGIN OF l_typ_us_monsters,
             monster_name         TYPE string,
             monster_lockbox_code TYPE string,
           END OF l_typ_us_monsters.

    TYPES: l_tt_us_monsters TYPE HASHED TABLE OF l_typ_us_monsters
                            WITH UNIQUE KEY monster_name.

    TYPES: BEGIN OF l_typ_us_results,
             laboratory TYPE string,
             t_result   TYPE l_tt_us_monsters,
           END OF l_typ_us_results.

    TYPES: l_tt_us_results TYPE STANDARD TABLE OF l_typ_us_results.

    DATA: us_result  TYPE l_typ_us_results,
          us_results TYPE l_tt_us_results.

    european_result-laboratory         = 'SECRET LABORATORY 51'.
    iban_code_record-monster_name      = 'FRED'.
    iban_code_record-monster_iban_code = 'AL47212110090000000235698741'.
    INSERT iban_code_record INTO TABLE european_result-t_result.

*--------------------------------------------------------------------*
* Important Bit - This DOES NOT work
*--------------------------------------------------------------------*
    MOVE-CORRESPONDING european_result TO us_result.

  ENDMETHOD.


  METHOD l03_39_corresponding_old_v2.
*--------------------------------------------------------------------*
* Listing 03.39:  Copying between Internal Tables with Different Structures before 7.4
*--------------------------------------------------------------------*
    TYPES: BEGIN OF l_typ_european_monsters,
             monster_name      TYPE string,
             monster_iban_code TYPE string,
           END OF l_typ_european_monsters.

    TYPES: l_tt_european_monsters
    TYPE HASHED TABLE OF l_typ_european_monsters
    WITH UNIQUE KEY monster_name.

    DATA: iban_code_record TYPE l_typ_european_monsters.

    TYPES: BEGIN OF l_typ_european_results,
             laboratory TYPE string,
             t_result   TYPE l_tt_european_monsters,
           END OF l_typ_european_results.

    TYPES: l_tt_european_results
    TYPE STANDARD TABLE OF l_typ_european_results.

    DATA: european_result  TYPE l_typ_european_results,
          european_results TYPE l_tt_european_results.

    TYPES: BEGIN OF l_typ_us_monsters,
             monster_name         TYPE string,
             monster_lockbox_code TYPE string,
           END OF l_typ_us_monsters.

    TYPES: l_tt_us_monsters TYPE HASHED TABLE OF l_typ_us_monsters
                            WITH UNIQUE KEY monster_name.

    TYPES: BEGIN OF l_typ_us_results,
             laboratory TYPE string,
             t_result   TYPE l_tt_us_monsters,
           END OF l_typ_us_results.

    TYPES: l_tt_us_results TYPE STANDARD TABLE OF l_typ_us_results.

    DATA: us_result  TYPE l_typ_us_results,
          us_results TYPE l_tt_us_results.

    european_result-laboratory         = 'SECRET LABORATORY 51'.
    iban_code_record-monster_name      = 'FRED'.
    iban_code_record-monster_iban_code = 'AL47212110090000000235698741'.
    INSERT iban_code_record INTO TABLE european_result-t_result.
    INSERT european_result  INTO TABLE european_results.

*--------------------------------------------------------------------*
* Important Bit - This Works - Takes 4 Lines
*--------------------------------------------------------------------*
    LOOP AT european_results ASSIGNING FIELD-SYMBOL(<european_result>).
      APPEND INITIAL LINE TO us_results ASSIGNING FIELD-SYMBOL(<us_result>).
      MOVE-CORRESPONDING <european_result> TO <us_result>.
    ENDLOOP.

  ENDMETHOD.


  METHOD l03_40_corresponding_new.
*--------------------------------------------------------------------*
* Listing 03.40:  Copying between Internal Tables with Different Structures in 7.4
*--------------------------------------------------------------------*
* Local Variables
    TYPES: BEGIN OF l_typ_european_monsters,
             monster_name      TYPE string,
             monster_iban_code TYPE string,
           END OF l_typ_european_monsters.

    TYPES: l_tt_european_monsters
    TYPE HASHED TABLE OF l_typ_european_monsters
    WITH UNIQUE KEY monster_name.

    DATA: iban_code_record TYPE l_typ_european_monsters.

    TYPES: BEGIN OF l_typ_european_results,
             laboratory TYPE string,
             t_result   TYPE l_tt_european_monsters,
           END OF l_typ_european_results.

    TYPES: l_tt_european_results
    TYPE STANDARD TABLE OF l_typ_european_results.

    DATA: european_result  TYPE l_typ_european_results,
          european_results TYPE l_tt_european_results.

    TYPES: BEGIN OF l_typ_us_monsters,
             monster_name         TYPE string,
             monster_lockbox_code TYPE string,
           END OF l_typ_us_monsters.

    TYPES: l_tt_us_monsters TYPE HASHED TABLE OF l_typ_us_monsters
                            WITH UNIQUE KEY monster_name.

    TYPES: BEGIN OF l_typ_us_results,
             laboratory TYPE string,
             t_result   TYPE l_tt_us_monsters,
           END OF l_typ_us_results.

    TYPES: l_tt_us_results TYPE STANDARD TABLE OF l_typ_us_results.

    DATA: us_result  TYPE l_typ_us_results,
          us_results TYPE l_tt_us_results.

    european_result-laboratory         = 'SECRET LABORATORY 51'.
    iban_code_record-monster_name      = 'FRED'.
    iban_code_record-monster_iban_code = 'AL47212110090000000235698741'.
    INSERT iban_code_record INTO TABLE european_result-t_result.
    INSERT european_result  INTO TABLE european_results.

*--------------------------------------------------------------------*
* Important Bit - This Works - Takes Only 1 Line
*--------------------------------------------------------------------*
    MOVE-CORRESPONDING european_results TO us_results.

  ENDMETHOD.


  METHOD l03_41_corresponding_dynamic.
*--------------------------------------------------------------------*
* Listing 03.41:  Dynamic MOVE-CORRESPONDING Usage
*--------------------------------------------------------------------*
* This example demonstrates building up the mapping rules dynamically
* at runtime to aid in the make (monster) to order business process
*--------------------------------------------------------------------*
* Incoming Parameters are
* - a record describing the customer requirements (Z4T_ORDER_ITEMS)
*   this comes from sales (taking customer orders)
* - a record describing possible brains available (Z4ST_MONSTER_POSSIBLE_BRAINS)
*   this comes from procurement (digging up graves)
* - the returning parameter is a ranked list of preferred brains
*   this is sent to production (Baron Frankenstein)
*--------------------------------------------------------------------*
* Local Variables
    DATA: mapping_record TYPE cl_abap_corresponding=>mapping_info,
          mapping_table  TYPE cl_abap_corresponding=>mapping_table.

    ""Simulate incoming customer requirements from sales
    DATA(is_customer_requirements) = VALUE z4t_order_items(
      usage_desired      = 'MORI'    ""Morris Dancer
      brain_size_desired = 'MICRO' ).""Microscopic

    ""Simulate incoming possible brains from procurement
    DATA(is_possible_brains) = VALUE z4st_monster_possible_brains(
      monster_number = '0000000001'
      monster_name   = 'JIMMY'
      biggest_brain  = 'EINSTIEN'
      smallest_brain = 'RENAMER'
      weirdest_brain = 'YANKOVICH'
      evilest_brain  = 'BANKER' ).

    mapping_record-level = 0.
    mapping_record-kind  = cl_abap_corresponding=>mapping_component.

    mapping_record-dstname = 'BEST_BRAIN_01'.

    IF is_customer_requirements-brain_size_desired = 'NORM'.""Normal Brain
      mapping_record-srcname = 'BIGGEST_BRAIN'.
    ELSE.
      mapping_record-srcname = 'SMALLEST_BRAIN'.
    ENDIF.

    APPEND mapping_record TO mapping_table.

    mapping_record-dstname = 'BEST_BRAIN_02'.

    IF is_customer_requirements-usage_desired = 'MORT'.""Mortgage Salesman
      mapping_record-srcname = 'EVILEST_BRAIN'.
    ELSEIF is_customer_requirements-usage_desired = 'MORI'.""Morris Dancer
      mapping_record-srcname = 'WEIRDEST_BRAIN'.
    ENDIF.

    APPEND mapping_record TO mapping_table.

    TRY.
        DATA(dynamic_mapper) =
        cl_abap_corresponding=>create(
            source            = is_possible_brains
            destination       = rs_best_brains
            mapping           = mapping_table ).

        dynamic_mapper->execute(
          EXPORTING source      = is_possible_brains
          CHANGING  destination = rs_best_brains    ).

      CATCH cx_corr_dyn_error ##NO_HANDLER.""In the example, in real life you need one
        ""Raise a Fatal Error Message
        RETURN.
    ENDTRY.

    ""If the RETURNING parameter is a structure, as in this method, but you are only interested
    ""in one field of that structure then you call the method as follows:-
    DATA(best_brain) = l03_41_corresponding_dynamic( )-best_brain_01.

  ENDMETHOD.


  METHOD l03_42_getting_row_no_old.
*--------------------------------------------------------------------*
* Listing 03.42:  Reading Internal Table to Get Row Number in 7.02
*--------------------------------------------------------------------*
    DATA:
      start_row         TYPE sy-tabix,
      table_of_monsters TYPE STANDARD TABLE OF z4t_monster_head,
      monster_number    TYPE z4de_monster_number VALUE '0000000001'.

    READ TABLE table_of_monsters
    WITH KEY monster_number = monster_number
    TRANSPORTING NO FIELDS.

    IF sy-subrc = 0.
      start_row = sy-tabix.
    ENDIF.

  ENDMETHOD.


  METHOD l03_43_getting_row_no_new.
*--------------------------------------------------------------------*
* Listing 03.43:  LINE_INDEX
*--------------------------------------------------------------------*
* Post 7.40 Syntax
*--------------------------------------------------------------------*
* Local Variables
    DATA:
      table_of_monsters TYPE STANDARD TABLE OF z4t_monster_head,
      monster_number    TYPE z4de_monster_number VALUE '0000000001'.

    DATA(start_row) = line_index( table_of_monsters[ monster_number = monster_number ] ).

    LOOP AT table_of_monsters FROM start_row ASSIGNING FIELD-SYMBOL(<monster_details>).
      ""Do Something
    ENDLOOP.

  ENDMETHOD.


  METHOD l03_44_getting_row_no_newer.
*--------------------------------------------------------------------*
* Listing 03.44:  Built-In Function LINE_INDEX at Operand Position
*--------------------------------------------------------------------*
* Post 7.40 Syntax - V2
*--------------------------------------------------------------------*
* Local Variables
    DATA:
      table_of_monsters TYPE STANDARD TABLE OF z4t_monster_head,
      monster_number    TYPE z4de_monster_number VALUE '0000000001'.

    LOOP AT table_of_monsters
      FROM line_index( table_of_monsters[ monster_number = monster_number ] )
      ASSIGNING FIELD-SYMBOL(<monster_details>).
      ""Do Something
    ENDLOOP.

* One Haunted Castle can be found at 50.4 degrees Latitude
  ENDMETHOD.


  METHOD l03_45_itab_row_exists_old.
*--------------------------------------------------------------------*
* Listing 03.45:  Checking If Internal Table Line Exists before 7.4
*--------------------------------------------------------------------*
* Pre 7.4 Syntax
*--------------------------------------------------------------------*
    DATA:
      table_of_monsters TYPE STANDARD TABLE OF z4t_monster_head,
      monster_number    TYPE z4de_monster_number VALUE '0000000001'.

    FIELD-SYMBOLS: <monster_details> LIKE LINE OF table_of_monsters.

    READ TABLE table_of_monsters ASSIGNING <monster_details>
    WITH KEY monster_number = monster_number.

    IF sy-subrc NE 0.
      APPEND INITIAL LINE TO table_of_monsters
      ASSIGNING <monster_details>.
    ENDIF.
    ADD 1 TO <monster_details>-sanity_percentage.

  ENDMETHOD.


  METHOD l03_46_itab_row_exists_new.
*--------------------------------------------------------------------*
* Listing 03.46:  Checking If Internal Table Line Exists in 7.4
*--------------------------------------------------------------------*
* Post 7.4 Syntax
*--------------------------------------------------------------------*
    DATA:
      table_of_monsters TYPE STANDARD TABLE OF z4t_monster_head,
      monster_number    TYPE z4de_monster_number VALUE '0000000001'.

    IF line_exists( table_of_monsters[ monster_number = monster_number ] ).
      READ TABLE table_of_monsters ASSIGNING FIELD-SYMBOL(<monster_details>)
      WITH KEY monster_number = monster_number.
    ELSE.
      APPEND INITIAL LINE TO table_of_monsters
      ASSIGNING <monster_details>.
    ENDIF.

    <monster_details>-sanity_percentage = <monster_details>-sanity_percentage + 1.

  ENDMETHOD.


  METHOD l03_47_itab_row_exists_newer.
*--------------------------------------------------------------------*
* Listing 03.47:  Code All in One Line, with No Reliance on SY-SUBRC
*--------------------------------------------------------------------*
* Post 7.4 Syntax V2
*--------------------------------------------------------------------*
    DATA:
      table_of_monsters TYPE STANDARD TABLE OF z4t_monster_head,
      monster_number    TYPE z4de_monster_number VALUE '0000000001'.

    IF line_exists( table_of_monsters[ monster_number = monster_number ] ).
      ""Do Something
    ENDIF.

  ENDMETHOD.


  METHOD l03_48_reduce.
*--------------------------------------------------------------------*
* Listing 03.48:  How Many Really Mad Monsters?
*--------------------------------------------------------------------*
* Local Variables
    DATA: neurotic_monsters TYPE STANDARD TABLE OF z4t_monster_head.
*--------------------------------------------------------------------*
* Fill up NEUROTIC_MONSTERS table, then...
*--------------------------------------------------------------------*
    DATA(mad_monsters_count) = REDUCE sy-tabix(
    INIT result = 0
    FOR  monster_details IN neurotic_monsters
    NEXT result = result +
    lcl_utilities=>add_1_if_true(
    zcl_4_monster_model=>is_mad( monster_details-monster_number ) ) ).

  ENDMETHOD.


  METHOD l03_49_group_by.
*--------------------------------------------------------------------*
* Listing 03.49:  GROUP BY
*--------------------------------------------------------------------*
* In this example we are trying to prove that bonkers monsters with
* bolts througth their neck have more heads per monster on average
* compared to bonkers monsters who like to ice skate.
* This is most likely a 100% correlation with the business problem
* you are trying to solve at work right at this moment.
*--------------------------------------------------------------------*
    TYPES: tt_monsters TYPE STANDARD TABLE OF z4t_monster_head
                       WITH DEFAULT KEY.

    DATA: monster_sub_set TYPE tt_monsters,
          total_heads     TYPE i.

    DATA(table_of_monsters) = VALUE tt_monsters(
    ( monster_number = '1' model = 'BTNK' no_of_heads = 3 )
    ( monster_number = '2' model = 'BTNK' no_of_heads = 4 )
    ( monster_number = '3' model = 'BTNK' no_of_heads = 2 )
    ( monster_number = '4' model = 'ISDD' no_of_heads = 1 )
    ( monster_number = '5' model = 'ISDD' no_of_heads = 1 )
     ).

    LOOP AT table_of_monsters ASSIGNING FIELD-SYMBOL(<monster_details>)
    GROUP BY ( model          = <monster_details>-model
               is_it_crackers = zcl_4_monster_model=>is_mad( <monster_details>-monster_number ) )
    ASSIGNING FIELD-SYMBOL(<monster_group_record>).

      CHECK <monster_group_record>-is_it_crackers = abap_true.

      CLEAR monster_sub_set.

      LOOP AT GROUP <monster_group_record> ASSIGNING FIELD-SYMBOL(<bonkers_monsters>).
        monster_sub_set =
        VALUE #( BASE monster_sub_set ( <bonkers_monsters> ) ).
      ENDLOOP.

      CLEAR total_heads.

      LOOP AT monster_sub_set ASSIGNING FIELD-SYMBOL(<sub_set_record>).
        total_heads = total_heads + <sub_set_record>-no_of_heads.
      ENDLOOP.

      WRITE:/ 'Bonkers Monsters of Type'(015),<monster_group_record>-model,' have '(016),total_heads,' heads'(017).

    ENDLOOP.

  ENDMETHOD.


  METHOD l03_50_table_extraction_old.
*--------------------------------------------------------------------*
* Listing 03.50:  Extracting One Table from Another before 7.4
*--------------------------------------------------------------------*
    DATA: ""Source Table
          all_monsters
          TYPE SORTED TABLE OF z4t_monster_head
          WITH NON-UNIQUE KEY monster_number
          WITH NON-UNIQUE SORTED KEY bonkers_ness
          COMPONENTS sanity_percentage,
          ""Target Table
          averagely_mad_monsters   TYPE STANDARD TABLE OF z4t_monster_head,
          an_averagely_mad_monster LIKE LINE OF averagely_mad_monsters.

    ""Extract Source to Target
    LOOP AT all_monsters ASSIGNING FIELD-SYMBOL(<monster_record>)
      WHERE sanity_percentage < 75.
      CLEAR an_averagely_mad_monster.
      MOVE-CORRESPONDING <monster_record> TO an_averagely_mad_monster.
      APPEND an_averagely_mad_monster     TO averagely_mad_monsters.
    ENDLOOP.""All Monsters

  ENDMETHOD.


  METHOD l03_51_table_extraction_new.
*--------------------------------------------------------------------*
* Listing 03.51:  Extracting One Table from Another in 7.40
*--------------------------------------------------------------------*
    DATA: all_monsters
             TYPE SORTED TABLE OF z4t_monster_head
             WITH NON-UNIQUE KEY monster_number
             WITH NON-UNIQUE SORTED KEY bonkers_ness
             COMPONENTS sanity_percentage.

    DATA(averagely_mad_monsters) =
    FILTER #( all_monsters USING KEY bonkers_ness
    WHERE sanity_percentage < CONV #( 75 ) ).

  ENDMETHOD.


  METHOD l03_52_fae_database.
*--------------------------------------------------------------------*
* Listing 03.52:  FOR ALL ENTRIES during Database Read
*--------------------------------------------------------------------*
    DATA: monster_deliveries
          TYPE SORTED TABLE OF z4t_deliveries
          WITH NON-UNIQUE KEY monster_number,
          all_monsters       TYPE STANDARD TABLE OF z4t_monster_head.

* Fill up table ALL_MONSTERS

    SELECT *
    FROM z4t_deliveries
    INTO CORRESPONDING FIELDS OF TABLE monster_deliveries
    FOR ALL ENTRIES IN all_monsters
    WHERE monster_number = all_monsters-monster_number.

  ENDMETHOD.


  METHOD l03_53_fae_itab.
*--------------------------------------------------------------------*
* Listing 03.53:  FOR ALL ENTRIES on Internal Table
*--------------------------------------------------------------------*
* In my humble opinion the requirement that both tables need to be
* SORTED or HASHED dramatically reduces the usefulness of this
*--------------------------------------------------------------------*
    DATA: monster_deliveries TYPE SORTED TABLE OF z4t_deliveries
                             WITH NON-UNIQUE KEY monster_number,
          all_monsters       TYPE SORTED TABLE OF z4t_monster_head
                             WITH UNIQUE KEY monster_number.

*--------------------------------------------------------------------*
* Fill up table ALL_MONSTERS
*--------------------------------------------------------------------*

*--------------------------------------------------------------------*
* Do a FAE on the interal table....
*--------------------------------------------------------------------*
    DATA(deliveries_our_monsters) =
    FILTER #( monster_deliveries IN all_monsters
    WHERE monster_number = monster_number ).

* The Monster whose hobby is Spotting Trains is Colored Red
  ENDMETHOD.


  METHOD l03_54_virtual_sorting.
*--------------------------------------------------------------------*
* Listing 03.54:  Virtual Sorting
*--------------------------------------------------------------------*
* This is a problem that actually happened...
*--------------------------------------------------------------------*
    TYPES: BEGIN OF l_typ_disputes,
             dispute_number TYPE c LENGTH 10,
           END OF l_typ_disputes.

    TYPES: BEGIN OF l_typ_credit_notes,
             dispute_number TYPE c LENGTH 10,
             credit_value   TYPE alv_curr,
             rejected       TYPE abap_bool,
           END OF   l_typ_credit_notes.

    DATA: dispute_table     TYPE STANDARD TABLE OF l_typ_disputes,
          credit_note_table TYPE STANDARD TABLE OF l_typ_credit_notes.

*--------------------------------------------------------------------*
* Fill up the two tables
*--------------------------------------------------------------------*

* Whatever....

*--------------------------------------------------------------------*
* Virtual Sorting...
*--------------------------------------------------------------------*
    DATA(dispute_indexes) = cl_abap_itab_utilities=>virtual_sort(
    im_virtual_source =
    VALUE #(
    ( source = REF #( credit_note_table )
    components =
    VALUE #( ( name = 'credit_value'
    descending = abap_true ) ) )
    ( source = REF #( dispute_table )
    components =
    VALUE #( ( name = 'dispute_number' ) ) ) ) ).

  ENDMETHOD.


  METHOD l03_55_virtual_sorting_part_2.
*--------------------------------------------------------------------*
* Listing 03.55: Using Virtual Sort Result
*--------------------------------------------------------------------*
* This is a problem that actually happened...
*--------------------------------------------------------------------*
    TYPES: BEGIN OF l_typ_disputes,
             dispute_number TYPE c LENGTH 10,
           END OF l_typ_disputes.

    TYPES: BEGIN OF l_typ_credit_notes,
             dispute_number TYPE c LENGTH 10,
             credit_value   TYPE alv_curr,
             rejected       TYPE abap_bool,
           END OF   l_typ_credit_notes.

    DATA: dispute_table     TYPE STANDARD TABLE OF l_typ_disputes,
          credit_note_table TYPE STANDARD TABLE OF l_typ_credit_notes.

*--------------------------------------------------------------------*
* Fill up the two tables
*--------------------------------------------------------------------*

* Whatever....

*--------------------------------------------------------------------*
* Virtual Sorting...
*--------------------------------------------------------------------*
    DATA(dispute_indexes) = cl_abap_itab_utilities=>virtual_sort(
    im_virtual_source =
    VALUE #(
    ( source = REF #( credit_note_table )
    components =
    VALUE #( ( name = 'credit_value'
    descending = abap_true ) ) )
    ( source = REF #( dispute_table )
    components =
    VALUE #( ( name = 'dispute_number' ) ) ) ) ).

*--------------------------------------------------------------------*
* Evaluate Results
*--------------------------------------------------------------------*
    DATA top_disputes TYPE STANDARD TABLE OF l_typ_disputes.

    LOOP AT dispute_indexes ASSIGNING FIELD-SYMBOL(<index>).
      APPEND dispute_table[ <index> ] TO top_disputes.
    ENDLOOP.

  ENDMETHOD.


  METHOD l03_56_query_ddic_no_cast.
*-----------------------------------------------------------------------*
* Listing 03.56:  Components of Specific Dictionary Structure without CAST
*-----------------------------------------------------------------------*
    DATA structure_description TYPE REF TO cl_abap_structdescr.
    structure_description
    ?= cl_abap_typedescr=>describe_by_name( 'Z4SP_MONSTER_HEADER_D' ).
    DATA structure_components TYPE abap_compdescr_tab.
    structure_components = structure_description->components.

  ENDMETHOD.


  METHOD l03_57_query_ddic_with_cast.
*--------------------------------------------------------------------*
* Listing 03.57:  Components of Specific Dictionary Structure with CAST
*--------------------------------------------------------------------*
    DATA(structure_components) = CAST cl_abap_structdescr(
    cl_abap_typedescr=>describe_by_name( 'Z4SP_MONSTER_HEADER_D' ) )->components.

  ENDMETHOD.


  METHOD l03_58_find_a_subclass_old.
*--------------------------------------------------------------------*
* Listing 03.58:  Trying to Find Subclass before 7.5
*--------------------------------------------------------------------*
* See method GET_ALV_GRID in clasas ZCL_SALV_MODEL in Chapter 10
*--------------------------------------------------------------------*
    DATA: full_screen_adapter TYPE REF TO cl_salv_fullscreen_adapter,
          container_adapter   TYPE REF TO cl_salv_grid_adapter.
    TRY.
        ""Presume full screen mode (No Container)
        ""Target FULL_SCREEN_ADAPTER = CL_SALV_FULLSCREEN_ADAPTER
        ""CL_SALV_FULLSCREEN_ADAPTER is a subclass of CL_SALV_ADAPTER
        full_screen_adapter ?= io_salv_adapter.
        ""Get the Grid
        ro_alv_grid = full_screen_adapter->get_grid( ).
      CATCH cx_sy_move_cast_error.
        ""We must be in container mode
        ""Target CONTAINER_ADAPTER = CL_SALV_GRID_ADAPTER
        ""CL_SALV_GRID_ADAPTER is a subclass of CL_SALV_ADAPTER
        container_adapter ?= io_salv_adapter.
        ro_alv_grid = container_adapter->get_grid( ).
    ENDTRY.

  ENDMETHOD.


  METHOD l03_59_find_a_subclass_new.
*--------------------------------------------------------------------*
* Listing 03.59:  Trying to Find Subclass in 7.5
*--------------------------------------------------------------------*
* See method GET_ALV_GRID in clasas ZCL_SALV_MODEL in Chapter 10
*--------------------------------------------------------------------*
    DATA: full_screen_adapter TYPE REF TO cl_salv_fullscreen_adapter,
          container_adapter   TYPE REF TO cl_salv_grid_adapter.

    IF io_salv_adapter IS INSTANCE OF cl_salv_fullscreen_adapter.
      full_screen_adapter ?= io_salv_adapter.
      ro_alv_grid = full_screen_adapter->get_grid( ).
    ELSEIF io_salv_adapter IS INSTANCE OF cl_salv_grid_adapter.
      container_adapter ?= io_salv_adapter.
      ro_alv_grid = container_adapter->get_grid( ).
    ENDIF.

  ENDMETHOD.


  METHOD l03_60_find_a_subclass_new_v2.
*--------------------------------------------------------------------*
* Listing 03.60:  Another Way to Find Subclass in 7.50
*--------------------------------------------------------------------*
* See method GET_ALV_GRID in clasas ZCL_SALV_MODEL in Chapter 10
*--------------------------------------------------------------------*

    CASE TYPE OF io_salv_adapter.
      WHEN TYPE cl_salv_fullscreen_adapter
      INTO DATA(full_screen_adapter).
        ro_alv_grid = full_screen_adapter->get_grid( ).
      WHEN TYPE cl_salv_grid_adapter
      INTO DATA(container_adapter).
        ro_alv_grid = container_adapter->get_grid( ).
      WHEN OTHERS.
        RETURN.
    ENDCASE.

  ENDMETHOD.


  METHOD l03_61_functional_method_plus.
*--------------------------------------------------------------------*
* Listing 03.61:  CHANGING and EXPORTING Parameters
*--------------------------------------------------------------------*
    DATA: something_spurious  TYPE string,
          something_unrelated TYPE string.

    DATA(bomb_name) = lcl_atom_bomb=>get_details(
    EXPORTING id_bomb_number         = '0000000001'
    IMPORTING ed_something_spurious  = something_spurious
    CHANGING  cd_something_unrelated = something_unrelated ).

  ENDMETHOD.
ENDCLASS.
",13691,True,2912.07847095428,median
"/*

  PrintHelloWorld.ino
  
  Use the (Arduino compatible) u8g2 function ""print""  to draw a text.
  Also use the Arduino F() macro to place the text into PROGMEM area.

  Universal 8bit Graphics Library (https://github.com/olikraus/u8g2/)

  Copyright (c) 2016, olikraus@gmail.com
  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.

  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.  

*/

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

/*
  U8glib Example Overview:
    Frame Buffer Examples: clearBuffer/sendBuffer. Fast, but may not work with all Arduino boards because of RAM consumption
    Page Buffer Examples: firstPage/nextPage. Less RAM usage, should work with all Arduino boards.
    U8x8 Text Only Example: No RAM usage, direct communication with display controller. No graphics, 8x8 Text only.
    
  This is a page buffer example.    
*/

// U8g2 Contructor List (Picture Loop Page Buffer)
// The complete list is available here: https://github.com/olikraus/u8g2/wiki/u8g2setupcpp
// Please update the pin numbers according to your setup. Use U8X8_PIN_NONE if the reset pin is not connected
//U8G2_SSD1306_128X64_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 12, /* dc=*/ 4, /* reset=*/ 6);	// Arduboy (Production, Kickstarter Edition)
//U8G2_SSD1306_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_3W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // All Boards without Reset of the Display
//U8G2_SSD1306_128X64_NONAME_1_6800 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_NONAME_1_8080 u8g2(U8G2_R0, 13, 11, 2, 3, 4, 5, 6, A4, /*enable=*/ 7, /*cs=*/ 10, /*dc=*/ 9, /*reset=*/ 8);
//U8G2_SSD1306_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SH1106_128X64_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SH1106_128X64_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SH1106_128X64_VCOMH0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// same as the NONAME variant, but maximizes setContrast() range
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ 21, /* data=*/ 20, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather M0 Basic Proto + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);   // Adafruit Feather ESP8266/32u4 Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // Adafruit ESP8266/32u4/ARM Boards + FeatherWing OLED
//U8G2_SSD1306_128X32_UNIVISION_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE, /* clock=*/ SCL, /* data=*/ SDA);   // pin remapping with ESP8266 HW I2C
//U8G2_SSD1306_64X48_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.66"" OLED breakout board, Uno: A4=SDA, A5=SCL, 5V powered
//U8G2_SSD1306_64X32_NONAME_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_64X32_1F_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
//U8G2_SSD1306_96X16_ER_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);   // EastRising 0.69"" OLED 
//U8G2_SSD1322_NHD_256X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1322_NHD_256X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Enable U8G2_16BIT in u8g2.h
//U8G2_SSD1325_NHD_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1325_NHD_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1327_SEEED_96X96_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1327_SEEED_96X96_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);	// Seeedstudio Grove OLED 96x96
//U8G2_SSD1329_128X96_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1329_128X96_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1305_128X32_NONAME_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_SSD1309_128X64_NONAME0_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME0_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_SSD1309_128X64_NONAME2_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_LD7032_60X32_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* cs=*/ 9, /* dc=*/ 10, /* reset=*/ 8);	// SW SPI Nano Board
//U8G2_LD7032_60X32_1_4W_SW_I2C u8g2(U8G2_R0, /* clock=*/ 11, /* data=*/ 12, /* reset=*/ U8X8_PIN_NONE);	// NOT TESTED!
//U8G2_UC1701_EA_DOGS102_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_UC1701_EA_DOGS102_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_PCD8544_84X48_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Nokia 5110 Display
//U8G2_PCD8544_84X48_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Nokia 5110 Display
//U8G2_PCF8812_96X65_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// Could be also PCF8814
//U8G2_PCF8812_96X65_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);						// Could be also PCF8814
//U8G2_KS0108_128X64_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ U8X8_PIN_NONE, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_KS0108_ERM19264_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*dc=*/ 17, /*cs0=*/ 14, /*cs1=*/ 15, /*cs2=*/ 16, /* reset=*/  U8X8_PIN_NONE); 	// Set R/W to low!
//U8G2_ST7920_192X32_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ U8X8_PIN_NONE, /*dc=*/ 17, /*reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_192X32_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18 /* A4 */, /*cs=*/ U8X8_PIN_NONE, /*dc/rs=*/ 17 /* A3 */, /*reset=*/ 15 /* A1 */);	// Remember to set R/W to 0 
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 18 /* A4 */ , /* data=*/ 16 /* A2 */, /* CS=*/ 17 /* A3 */, /* reset=*/ U8X8_PIN_NONE);
//U8G2_ST7920_128X64_1_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM128_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_64128N_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_EA_DOGM132_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_EA_DOGM132_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ U8X8_PIN_NONE);	// DOGM132 Shield
//U8G2_ST7565_ZOLEN_128X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ZOLEN_128X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_LM6059_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// Adafruit ST7565 GLCD
//U8G2_ST7565_LM6059_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);			// Adafruit ST7565 GLCD
//U8G2_ST7565_ERC12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_ERC12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12832_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7565_NHD_C12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_ST7567_PI_132X64_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_PI_132X64_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  // Pax Instruments Shield, LCD_BL=6
//U8G2_ST7567_JLX12864_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7567_JLX12864_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 7, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_NT7534_TG12864R_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_ST7588_JLX12864_1_SW_I2C u8g2(U8G2_R0, /* clock=*/ SCL, /* data=*/ SDA, /* reset=*/ 5);  
//U8G2_ST7588_JLX12864_1_HW_I2C u8g2(U8G2_R0, /* reset=*/ 5);
//U8G2_IST3020_ERC19264_1_6800 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 28, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect WR pin with GND
//U8G2_IST3020_ERC19264_1_8080 u8g2(U8G2_R0, 44, 43, 42, 41, 40, 39, 38, 37,  /*enable=*/ 29, /*cs=*/ 32, /*dc=*/ 30, /*reset=*/ 31); // Connect RD pin with 3.3V
//U8G2_IST3020_ERC19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);
//U8G2_LC7981_160X80_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_160X160_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_LC7981_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 18, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RW with GND
//U8G2_SED1520_122X32_1 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*dc=*/ A0, /*e1=*/ A3, /*e2=*/ A2, /* reset=*/  A4); 	// Set R/W to low!
//U8G2_T6963_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_T6963_256X64_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect RD with +5V, FS0 and FS1 with GND
//U8G2_SED1330_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_SED1330_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_RA8835_NHD_240X128_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7, /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // Connect /RD = E with +5V, enable is /WR = RW, FG with GND, 14=Uno Pin A0
//U8G2_RA8835_NHD_240X128_1_6800 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 17, /*cs=*/ 14, /*dc=*/ 15, /*reset=*/ 16); // A0 is dc pin, /WR = RW = GND, enable is /RD = E
//U8G2_UC1604_JLX19264_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1604_JLX19264_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  
//U8G2_UC1608_ERC24064_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1608_ERC240120_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8); 
//U8G2_UC1608_240X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);  // SW SPI, Due ERC24064-1 Test Setup
//U8G2_UC1610_EA_DOGXL160_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1610_EA_DOGXL160_1_4W_HW_SPI u8g2(U8G2_R0, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/  U8X8_PIN_NONE);
//U8G2_UC1611_EA_DOGM240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGM240 Test Board
//U8G2_UC1611_EA_DOGM240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_2ND_HW_I2C u8g2(U8G2_R0, /* reset=*/ 8);	// Due, 2nd I2C, DOGXL240 Test Board
//U8G2_UC1611_EA_DOGXL240_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);   // SW SPI, Due DOGXL240 Test Board
//U8G2_UC1611_EW50850_1_8080 u8g2(U8G2_R0, 8, 9, 10, 11, 4, 5, 6, 7,  /*enable=*/ 18, /*cs=*/ 3, /*dc=*/ 16, /*reset=*/ 16); // 240x160, Connect RD/WR1 pin with 3.3V, CS is aktive high
//U8G2_SSD1606_172X72_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);		// eInk/ePaper Display
//U8G2_SSD1607_200X200_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// eInk/ePaper Display, original LUT from embedded artists
//U8G2_IL3820_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// WaveShare 2.9 inch eInk/ePaper Display, enable 16 bit mode for this display!
//U8G2_IL3820_V2_296X128_1_4W_SW_SPI u8g2(U8G2_R0, /* clock=*/ 13, /* data=*/ 11, /* cs=*/ 10, /* dc=*/ 9, /* reset=*/ 8);	// ePaper Display, lesser flickering and faster speed, enable 16 bit mode for this display!



// End of constructor list


void setup(void) {
  u8g2.begin();
}

void loop(void) {
  u8g2.setFont(u8g2_font_ncenB14_tr);
  u8g2.firstPage();
  do {
    u8g2.setCursor(0, 20);
    u8g2.print(F(""Hello World!""));
  } while ( u8g2.nextPage() );
  delay(1000);
}

",8410,True,2575.024878738479,median
"/**
 * Copyright (c) 2007-2015, Timothy Stack
 *
 * 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 Timothy Stack 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 REGENTS 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 REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include ""config.h""

#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <strings.h>

#include ""yajlpp.hh""
#include ""yajlpp_def.hh""
#include ""sql_util.hh""
#include ""log_format.hh""
#include ""log_vtab_impl.hh""
#include ""ptimec.hh""
#include ""log_search_table.hh""
#include ""command_executor.hh""

using namespace std;

/*
 * Supported formats:
 *   generic
 *   syslog
 *   apache
 *   tcpdump
 *   strace
 *   vstrace
 *   csv (?)
 *   file system (?)
 *   plugins
 *   vmstat
 *   iostat
 */

string_attr_type logline::L_PREFIX(""prefix"");
string_attr_type logline::L_TIMESTAMP(""timestamp"");
string_attr_type logline::L_FILE(""file"");
string_attr_type logline::L_PARTITION(""partition"");
string_attr_type logline::L_MODULE(""module"");
string_attr_type logline::L_OPID(""opid"");
string_attr_type logline::L_META(""meta"");

external_log_format::mod_map_t external_log_format::MODULE_FORMATS;
std::vector<external_log_format *> external_log_format::GRAPH_ORDERED_FORMATS;

struct line_range logline_value::origin_in_full_msg(const char *msg, size_t len) const
{
    if (this->lv_sub_offset == 0) {
        return this->lv_origin;
    }

    if (len == -1) {
        len = strlen(msg);
    }

    struct line_range retval = this->lv_origin;
    const char *last = msg, *msg_end = msg + len;

    for (int lpc = 0; lpc < this->lv_sub_offset; lpc++) {
        const auto *next = (const char *) memchr(last, '\\n', msg_end - last);
        require(next != NULL);

        next += 1;
        int amount = (next - last);

        retval.lr_start += amount;
        if (retval.lr_end != -1) {
            retval.lr_end += amount;
        }

        last = next + 1;
    }

    if (retval.lr_end == -1) {
        const auto *eol = (const char *) memchr(last, '\\n', msg_end - last);

        if (eol == nullptr) {
            retval.lr_end = len;
        } else {
            retval.lr_end = eol - msg;
        }
    }

    return retval;
}

vector<log_format *> log_format::lf_root_formats;

vector<log_format *> &log_format::get_root_formats()
{
    return lf_root_formats;
}

static bool next_format(const std::vector<std::shared_ptr<external_log_format::pattern>> &patterns,
                        int &index,
                        int &locked_index)
{
    bool retval = true;

    if (locked_index == -1) {
        index += 1;
        if (index >= (int)patterns.size()) {
            retval = false;
        }
    }
    else if (index == locked_index) {
        retval = false;
    }
    else {
        index = locked_index;
    }

    return retval;
}

bool log_format::next_format(pcre_format *fmt, int &index, int &locked_index)
{
    bool retval = true;

    if (locked_index == -1) {
        index += 1;
        if (fmt[index].name == NULL) {
            retval = false;
        }
    }
    else if (index == locked_index) {
        retval = false;
    }
    else {
        index = locked_index;
    }

    return retval;
}

const char *log_format::log_scanf(const char *line,
                                  size_t len,
                                  pcre_format *fmt,
                                  const char *time_fmt[],
                                  struct exttm *tm_out,
                                  struct timeval *tv_out,
                                  ...)
{
    int curr_fmt = -1;
    const char *retval = NULL;
    bool done = false;
    pcre_input pi(line, 0, len);
    pcre_context_static<128> pc;
    va_list args;
    int pat_index = this->last_pattern_index();

    while (!done && next_format(fmt, curr_fmt, pat_index)) {
        va_start(args, tv_out);

        pi.reset(line, 0, len);
        if (!fmt[curr_fmt].pcre.match(pc, pi, PCRE_NO_UTF8_CHECK)) {
            retval = NULL;
        }
        else {
            pcre_context::capture_t *ts = pc[fmt[curr_fmt].pf_timestamp_index];

            for (auto &iter : pc) {
                pcre_context::capture_t *cap = va_arg(
                        args, pcre_context::capture_t *);

                *cap = iter;
            }

            retval = this->lf_date_time.scan(
                    pi.get_substr_start(ts), ts->length(), NULL, tm_out, *tv_out);

            if (retval) {
                if (curr_fmt != pat_index) {
                    this->lf_pattern_locks.emplace_back(0, curr_fmt);
                }
                this->lf_timestamp_flags = tm_out->et_flags;
                done = true;
            }
        }

        va_end(args);
    }

    return retval;
}

void log_format::check_for_new_year(std::vector<logline> &dst, exttm etm,
                                    struct timeval log_tv)
{
    if (dst.empty()) {
        return;
    }

    time_t diff = dst.back().get_time() - log_tv.tv_sec;
    int off_year = 0, off_month = 0, off_day = 0, off_hour = 0;
    std::vector<logline>::iterator iter;
    bool do_change = true;

    if (diff <= 0) {
        return;
    }
    if ((etm.et_flags & ETF_MONTH_SET) && diff >= (24 * 60 * 60)) {
        off_year = 1;
    } else if (diff >= (24 * 60 * 60)) {
        off_month = 1;
    } else if (!(etm.et_flags & ETF_DAY_SET) && (diff >= (60 * 60))) {
        off_day = 1;
    } else if (!(etm.et_flags & ETF_DAY_SET)) {
        off_hour = 1;
    } else {
        do_change = false;
    }

    if (!do_change) {
        return;
    }
    log_debug(""%d:detected time rollover; offsets=%d %d %d %d"", dst.size(),
              off_year, off_month, off_day, off_hour);
    for (iter = dst.begin(); iter != dst.end(); iter++) {
        time_t     ot = iter->get_time();
        struct tm otm;

        gmtime_r(&ot, &otm);
        otm.tm_year -= off_year;
        otm.tm_mon  -= off_month;
        otm.tm_mday -= off_day;
        otm.tm_hour -= off_hour;
        iter->set_time(tm2sec(&otm));
    }
}

/*
 * XXX This needs some cleanup. 
 */
struct json_log_userdata {
    json_log_userdata(shared_buffer_ref &sbr)
            : jlu_format(NULL), jlu_line(NULL), jlu_base_line(NULL),
              jlu_sub_line_count(1), jlu_handle(NULL), jlu_line_value(NULL),
              jlu_line_size(0), jlu_sub_start(0), jlu_shared_buffer(sbr) {

    };

    external_log_format *jlu_format;
    const logline *jlu_line;
    logline *jlu_base_line;
    int jlu_sub_line_count;
    yajl_handle jlu_handle;
    const char *jlu_line_value;
    size_t jlu_line_size;
    size_t jlu_sub_start;
    shared_buffer_ref &jlu_shared_buffer;
};

static int read_json_field(yajlpp_parse_context *ypc, const unsigned char *str, size_t len);

static int read_json_null(yajlpp_parse_context *ypc)
{
    json_log_userdata *jlu = (json_log_userdata *)ypc->ypc_userdata;
    const intern_string_t field_name = ypc->get_path();

    jlu->jlu_sub_line_count += jlu->jlu_format->value_line_count(
        field_name, ypc->is_level(1));

    return 1;
}

static int read_json_bool(yajlpp_parse_context *ypc, int val)
{
    json_log_userdata *jlu = (json_log_userdata *)ypc->ypc_userdata;
    const intern_string_t field_name = ypc->get_path();

    jlu->jlu_sub_line_count += jlu->jlu_format->value_line_count(
        field_name, ypc->is_level(1));

    return 1;
}

static int read_json_int(yajlpp_parse_context *ypc, long long val)
{
    json_log_userdata *jlu = (json_log_userdata *)ypc->ypc_userdata;
    const intern_string_t field_name = ypc->get_path();

    if (jlu->jlu_format->lf_timestamp_field == field_name) {
        long long divisor = jlu->jlu_format->elf_timestamp_divisor;
        struct timeval tv;

        tv.tv_sec = val / divisor;
        tv.tv_usec = (val % divisor) * (1000000.0 / divisor);
        jlu->jlu_base_line->set_time(tv);
    }
    else if (jlu->jlu_format->elf_level_field == field_name) {
        if (jlu->jlu_format->elf_level_pairs.empty()) {
            char level_buf[128];

            snprintf(level_buf, sizeof(level_buf), ""%lld"", val);

            pcre_input pi(level_buf);
            pcre_context::capture_t level_cap = {0, (int) strlen(level_buf)};

            jlu->jlu_base_line->set_level(jlu->jlu_format->convert_level(pi, &level_cap));
        } else {
            vector<pair<int64_t, log_level_t> >::iterator iter;

            for (iter = jlu->jlu_format->elf_level_pairs.begin();
                 iter != jlu->jlu_format->elf_level_pairs.end();
                 ++iter) {
                if (iter->first == val) {
                    jlu->jlu_base_line->set_level(iter->second);
                    break;
                }
            }
        }
    }

    jlu->jlu_sub_line_count += jlu->jlu_format->value_line_count(
        field_name, ypc->is_level(1));

    return 1;
}

static int read_json_double(yajlpp_parse_context *ypc, double val)
{
    json_log_userdata *jlu = (json_log_userdata *)ypc->ypc_userdata;
    const intern_string_t field_name = ypc->get_path();

    if (jlu->jlu_format->lf_timestamp_field == field_name) {
        double divisor = jlu->jlu_format->elf_timestamp_divisor;
        struct timeval tv;

        tv.tv_sec = val / divisor;
        tv.tv_usec = fmod(val, divisor) * (1000000.0 / divisor);
        jlu->jlu_base_line->set_time(tv);
    }

    jlu->jlu_sub_line_count += jlu->jlu_format->value_line_count(
        field_name, ypc->is_level(1));

    return 1;
}

static int json_array_start(void *ctx)
{
    yajlpp_parse_context *ypc = (yajlpp_parse_context *)ctx;
    json_log_userdata *jlu = (json_log_userdata *)ypc->ypc_userdata;

    if (ypc->ypc_path_index_stack.size() == 2) {
        const intern_string_t field_name = ypc->get_path_fragment_i(0);

        jlu->jlu_sub_line_count += jlu->jlu_format->value_line_count(field_name, true);
        jlu->jlu_sub_start = yajl_get_bytes_consumed(jlu->jlu_handle) - 1;
    }

    return 1;
}

static int json_array_end(void *ctx)
{
    yajlpp_parse_context *ypc = (yajlpp_parse_context *)ctx;
    json_log_userdata *jlu = (json_log_userdata *)ypc->ypc_userdata;

    if (ypc->ypc_path_index_stack.size() == 1) {
        const intern_string_t field_name = ypc->get_path_fragment_i(0);
        size_t sub_end = yajl_get_bytes_consumed(jlu->jlu_handle);
        shared_buffer_ref sbr;

        sbr.subset(jlu->jlu_shared_buffer, jlu->jlu_sub_start,
            sub_end - jlu->jlu_sub_start);
        jlu->jlu_format->jlf_line_values.push_back(
            logline_value(field_name, sbr));
        jlu->jlu_format->jlf_line_values.back().lv_kind = logline_value::VALUE_JSON;
    }

    return 1;
}

static struct json_path_handler json_log_handlers[] = {
    json_path_handler(""^/\\\\w+$"").
    add_cb(read_json_null).
    add_cb(read_json_bool).
    add_cb(read_json_int).
    add_cb(read_json_double).
    add_cb(read_json_field),

    json_path_handler()
};

static int rewrite_json_field(yajlpp_parse_context *ypc, const unsigned char *str, size_t len);

static int rewrite_json_null(yajlpp_parse_context *ypc)
{
    json_log_userdata *jlu = (json_log_userdata *)ypc->ypc_userdata;
    const intern_string_t field_name = ypc->get_path();

    if (!ypc->is_level(1) && !jlu->jlu_format->has_value_def(field_name)) {
        return 1;
    }
    jlu->jlu_format->jlf_line_values.emplace_back(field_name);

    return 1;
}

static int rewrite_json_bool(yajlpp_parse_context *ypc, int val)
{
    json_log_userdata *jlu = (json_log_userdata *)ypc->ypc_userdata;
    const intern_string_t field_name = ypc->get_path();

    if (!ypc->is_level(1) && !jlu->jlu_format->has_value_def(field_name)) {
        return 1;
    }
    jlu->jlu_format->jlf_line_values.emplace_back(field_name, (bool)val);

    return 1;
}

static int rewrite_json_int(yajlpp_parse_context *ypc, long long val)
{
    json_log_userdata *jlu = (json_log_userdata *)ypc->ypc_userdata;
    const intern_string_t field_name = ypc->get_path();

    if (!ypc->is_level(1) && !jlu->jlu_format->has_value_def(field_name)) {
        return 1;
    }
    jlu->jlu_format->jlf_line_values.emplace_back(field_name, (int64_t)val);

    return 1;
}

static int rewrite_json_double(yajlpp_parse_context *ypc, double val)
{
    json_log_userdata *jlu = (json_log_userdata *)ypc->ypc_userdata;
    const intern_string_t field_name = ypc->get_path();

    if (!ypc->is_level(1) && !jlu->jlu_format->has_value_def(field_name)) {
        return 1;
    }
    jlu->jlu_format->jlf_line_values.emplace_back(field_name, val);

    return 1;
}

static struct json_path_handler json_log_rewrite_handlers[] = {
    json_path_handler(""^/\\\\w+$"")
        .add_cb(rewrite_json_null)
        .add_cb(rewrite_json_bool)
        .add_cb(rewrite_json_int)
        .add_cb(rewrite_json_double)
        .add_cb(rewrite_json_field),

    json_path_handler()
};

bool external_log_format::scan_for_partial(shared_buffer_ref &sbr, size_t &len_out)
{
    if (this->elf_type != ELF_TYPE_TEXT) {
        return false;
    }

    auto pat = this->elf_pattern_order[this->last_pattern_index()];
    pcre_input pi(sbr.get_data(), 0, sbr.length());

    if (!this->elf_multiline) {
        len_out = pat->p_pcre->match_partial(pi);
        return true;
    }

    if (pat->p_timestamp_end == -1 || pat->p_timestamp_end > (int)sbr.length()) {
        len_out = 0;
        return false;
    }

    len_out = pat->p_pcre->match_partial(pi);
    return (int)len_out > pat->p_timestamp_end;
}

log_format::scan_result_t external_log_format::scan(nonstd::optional<logfile *> lf,
                                                    std::vector<logline> &dst,
                                                    off_t offset,
                                                    shared_buffer_ref &sbr)
{
    if (this->elf_type == ELF_TYPE_JSON) {
        yajlpp_parse_context &ypc = *(this->jlf_parse_context);
        logline ll(offset, 0, 0, LEVEL_INFO);
        yajl_handle handle = this->jlf_yajl_handle.in();
        json_log_userdata jlu(sbr);

        if (sbr.empty()) {
            return log_format::SCAN_INCOMPLETE;
        }

        const auto *line_data = (const unsigned char *) sbr.get_data();
        size_t line_end = sbr.length();

        if (line_end > 0) {
            line_end -= 1;
        }
        while (line_end > 0 && isspace(line_data[line_end])) {
            line_end -= 1;
        }

        if (line_end == 0 || line_data[line_end] != '}') {
            return log_format::SCAN_INCOMPLETE;
        }

        yajl_reset(handle);
        ypc.set_static_handler(json_log_handlers[0]);
        ypc.ypc_userdata = &jlu;
        ypc.ypc_ignore_unused = true;
        ypc.ypc_alt_callbacks.yajl_start_array = json_array_start;
        ypc.ypc_alt_callbacks.yajl_start_map = json_array_start;
        ypc.ypc_alt_callbacks.yajl_end_array = NULL;
        ypc.ypc_alt_callbacks.yajl_end_map = NULL;
        jlu.jlu_format = this;
        jlu.jlu_base_line = &ll;
        jlu.jlu_line_value = sbr.get_data();
        jlu.jlu_line_size = sbr.length();
        jlu.jlu_handle = handle;
        if (yajl_parse(handle, line_data, sbr.length()) == yajl_status_ok &&
            yajl_complete_parse(handle) == yajl_status_ok) {
            if (ll.get_time() == 0) {
                return log_format::SCAN_NO_MATCH;
            }

            for (int lpc = 0; lpc < jlu.jlu_sub_line_count; lpc++) {
                ll.set_sub_offset(lpc);
                if (lpc > 0) {
                    ll.set_level((log_level_t) (ll.get_level_and_flags() |
                        LEVEL_CONTINUED));
                }
                dst.push_back(ll);
            }
        }
        else {
            unsigned char *msg;

            msg = yajl_get_error(handle, 1, (const unsigned char *)sbr.get_data(), sbr.length());
            if (msg != NULL) {
                log_debug(""Unable to parse line at offset %d: %s"", offset, msg);
                yajl_free_error(handle, msg);
            }
            return log_format::SCAN_INCOMPLETE;
        }

        return log_format::SCAN_MATCH;
    }

    pcre_input pi(sbr.get_data(), 0, sbr.length());
    pcre_context_static<128> pc;
    int curr_fmt = -1, orig_lock = this->last_pattern_index();
    int pat_index = orig_lock;

    while (::next_format(this->elf_pattern_order, curr_fmt, pat_index)) {
        auto fpat = this->elf_pattern_order[curr_fmt];
        pcrepp *pat = fpat->p_pcre;

        if (fpat->p_module_format) {
            continue;
        }

        if (!pat->match(pc, pi)) {
            if (!this->lf_pattern_locks.empty() && pat_index != -1) {
                log_debug(""no match on pattern %d"", pat_index);
                curr_fmt = -1;
                pat_index = -1;
            }
            continue;
        }

        pcre_context::capture_t *ts = pc[fpat->p_timestamp_field_index];
        pcre_context::capture_t *level_cap = pc[fpat->p_level_field_index];
        pcre_context::capture_t *mod_cap = pc[fpat->p_module_field_index];
        pcre_context::capture_t *opid_cap = pc[fpat->p_opid_field_index];
        pcre_context::capture_t *body_cap = pc[fpat->p_body_field_index];
        const char *ts_str = pi.get_substr_start(ts);
        const char *last;
        struct exttm log_time_tm;
        struct timeval log_tv;
        uint8_t mod_index = 0, opid = 0;

        if ((last = this->lf_date_time.scan(ts_str,
                                            ts->length(),
                                            this->get_timestamp_formats(),
                                            &log_time_tm,
                                            log_tv)) == NULL) {
            this->lf_date_time.unlock();
            if ((last = this->lf_date_time.scan(ts_str,
                                                ts->length(),
                                                this->get_timestamp_formats(),
                                                &log_time_tm,
                                                log_tv)) == NULL) {
                continue;
            }
        }

        log_level_t level = this->convert_level(pi, level_cap);

        this->lf_timestamp_flags = log_time_tm.et_flags;

        if (!((log_time_tm.et_flags & ETF_DAY_SET) &&
              (log_time_tm.et_flags & ETF_MONTH_SET) &&
              (log_time_tm.et_flags & ETF_YEAR_SET))) {
            this->check_for_new_year(dst, log_time_tm, log_tv);
        }

        if (opid_cap != nullptr) {
            opid = hash_str(pi.get_substr_start(opid_cap), opid_cap->length());
        }

        if (mod_cap != nullptr) {
            intern_string_t mod_name = intern_string::lookup(
                    pi.get_substr_start(mod_cap), mod_cap->length());
            auto mod_iter = MODULE_FORMATS.find(mod_name);

            if (mod_iter == MODULE_FORMATS.end()) {
                mod_index = module_scan(pi, body_cap, mod_name);
            }
            else if (mod_iter->second.mf_mod_format) {
                mod_index = mod_iter->second.mf_mod_format->lf_mod_index;
            }
        }

        for (auto value_index : fpat->p_numeric_value_indexes) {
            const indexed_value_def &ivd = fpat->p_value_by_index[value_index];
            const value_def &vd = *ivd.ivd_value_def;
            pcre_context::capture_t *num_cap = pc[ivd.ivd_index];

            if (num_cap != nullptr && num_cap->is_valid()) {
                const struct scaling_factor *scaling = nullptr;

                if (ivd.ivd_unit_field_index >= 0) {
                    pcre_context::iterator unit_cap = pc[ivd.ivd_unit_field_index];

                    if (unit_cap != nullptr && unit_cap->is_valid()) {
                        intern_string_t unit_val = intern_string::lookup(
                            pi.get_substr_start(unit_cap), unit_cap->length());
                        std::map<const intern_string_t, scaling_factor>::const_iterator unit_iter;

                        unit_iter = vd.vd_unit_scaling.find(unit_val);
                        if (unit_iter != vd.vd_unit_scaling.end()) {
                            const struct scaling_factor &sf = unit_iter->second;

                            scaling = &sf;
                        }
                    }
                }

                const char *num_cap_start = pi.get_substr_start(num_cap);
                const char *num_cap_end = num_cap_start + num_cap->length();
                double dvalue = strtod(num_cap_start, (char **) &num_cap_end);

                if (num_cap_end == num_cap_start + num_cap->length()) {
                    if (scaling != nullptr) {
                        scaling->scale(dvalue);
                    }
                    this->lf_value_stats[vd.vd_values_index].add_value(dvalue);
                }
            }
        }

        dst.emplace_back(offset, log_tv, level, mod_index, opid);

        if (orig_lock != curr_fmt) {
            log_debug(""changing pattern lock %d -> %d"", orig_lock, curr_fmt);
            this->lf_pattern_locks.emplace_back(dst.size() - 1, curr_fmt);
        }
        return log_format::SCAN_MATCH;
    }

    return log_format::SCAN_NO_MATCH;
}

uint8_t external_log_format::module_scan(const pcre_input &pi,
                                         pcre_context::capture_t *body_cap,
                                         const intern_string_t &mod_name)
{
    uint8_t mod_index;
    body_cap->ltrim(pi.get_string());
    pcre_input body_pi(pi.get_substr_start(body_cap), 0, body_cap->length());
    vector<external_log_format *> &ext_fmts = GRAPH_ORDERED_FORMATS;
    pcre_context_static<128> pc;
    module_format mf;

    for (auto elf : ext_fmts) {
        int curr_fmt = -1, fmt_lock = -1;

        while (::next_format(elf->elf_pattern_order, curr_fmt, fmt_lock)) {
            auto fpat = elf->elf_pattern_order[curr_fmt];
            pcrepp *pat = fpat->p_pcre;

            if (!fpat->p_module_format) {
                continue;
            }

            if (!pat->match(pc, body_pi)) {
                continue;
            }

            log_debug(""%s:module format found -- %s (%d)"",
                      mod_name.get(),
                      elf->get_name().get(),
                      elf->lf_mod_index);

            mod_index = elf->lf_mod_index;
            mf.mf_mod_format = (external_log_format *) elf->specialized(curr_fmt).release();
            MODULE_FORMATS[mod_name] = mf;

            return mod_index;
        }
    }

    MODULE_FORMATS[mod_name] = mf;

    return 0;
}

void external_log_format::annotate(uint64_t line_number, shared_buffer_ref &line, string_attrs_t &sa,
                                   std::vector<logline_value> &values, bool annotate_module) const
{
    pcre_context_static<128> pc;
    pcre_input pi(line.get_data(), 0, line.length());
    struct line_range lr;
    pcre_context::capture_t *cap, *body_cap, *module_cap = NULL;

    if (this->elf_type != ELF_TYPE_TEXT) {
        values = this->jlf_line_values;
        sa = this->jlf_line_attrs;
        return;
    }

    int pat_index = this->pattern_index_for_line(line_number);
    pattern &pat = *this->elf_pattern_order[pat_index];

    if (!pat.p_pcre->match(pc, pi)) {
        // A continued line still needs a body.
        lr.lr_start = 0;
        lr.lr_end = line.length();
        sa.emplace_back(lr, &textview_curses::SA_BODY);
        return;
    }

    if (!pat.p_module_format) {
        cap = pc[pat.p_timestamp_field_index];
        lr.lr_start = cap->c_begin;
        lr.lr_end = cap->c_end;
        sa.push_back(string_attr(lr, &logline::L_TIMESTAMP));

        if (pat.p_module_field_index != -1) {
            module_cap = pc[pat.p_module_field_index];
            if (module_cap != NULL && module_cap->is_valid()) {
                lr.lr_start = module_cap->c_begin;
                lr.lr_end = module_cap->c_end;
                sa.push_back(string_attr(lr, &logline::L_MODULE));
            }
        }

        cap = pc[pat.p_opid_field_index];
        if (cap != NULL && cap->is_valid()) {
            lr.lr_start = cap->c_begin;
            lr.lr_end = cap->c_end;
            sa.push_back(string_attr(lr, &logline::L_OPID));
        }
    }

    body_cap = pc[pat.p_body_field_index];
    if (body_cap != NULL && body_cap->c_begin != -1) {
        lr.lr_start = body_cap->c_begin;
        lr.lr_end = body_cap->c_end;
    }
    else {
        lr.lr_start = line.length();
        lr.lr_end = line.length();
    }
    sa.push_back(string_attr(lr, &textview_curses::SA_BODY));

    for (size_t lpc = 0; lpc < pat.p_value_by_index.size(); lpc++) {
        const indexed_value_def &ivd = pat.p_value_by_index[lpc];
        const struct scaling_factor *scaling = NULL;
        pcre_context::capture_t *cap = pc[ivd.ivd_index];
        const value_def &vd = *ivd.ivd_value_def;
        shared_buffer_ref field;

        if (ivd.ivd_unit_field_index >= 0) {
            pcre_context::iterator unit_cap = pc[ivd.ivd_unit_field_index];

            if (unit_cap != NULL && unit_cap->c_begin != -1) {
                intern_string_t unit_val = intern_string::lookup(
                    pi.get_substr_start(unit_cap), unit_cap->length());
                map<const intern_string_t, scaling_factor>::const_iterator unit_iter;

                unit_iter = vd.vd_unit_scaling.find(unit_val);
                if (unit_iter != vd.vd_unit_scaling.end()) {
                    const struct scaling_factor &sf = unit_iter->second;

                    scaling = &sf;
                }
            }
        }

        field.subset(line, cap->c_begin, cap->length());

        values.emplace_back(vd.vd_name,
                            vd.vd_kind,
                            field,
                            vd.vd_identifier,
                            scaling,
                            vd.vd_column,
                            cap->c_begin,
                            cap->c_end,
                            pat.p_module_format,
                            this);
        values.back().lv_hidden = vd.vd_hidden || vd.vd_user_hidden;
    }

    if (annotate_module && module_cap != NULL && body_cap != NULL &&
            body_cap->is_valid()) {
        intern_string_t mod_name = intern_string::lookup(
                pi.get_substr_start(module_cap), module_cap->length());
        auto mod_iter = MODULE_FORMATS.find(mod_name);

        if (mod_iter != MODULE_FORMATS.end() &&
                mod_iter->second.mf_mod_format != NULL) {
            module_format &mf = mod_iter->second;
            shared_buffer_ref body_ref;

            body_cap->ltrim(line.get_data());
            body_ref.subset(line, body_cap->c_begin, body_cap->length());
            mf.mf_mod_format->annotate(line_number, body_ref, sa, values, false);
            for (auto &value : values) {
                if (!value.lv_from_module) {
                    continue;
                }
                value.lv_origin.lr_start += body_cap->c_begin;
                value.lv_origin.lr_end += body_cap->c_begin;
            }
        }
    }
}

void external_log_format::rewrite(exec_context &ec,
                                  shared_buffer_ref &line,
                                  string_attrs_t &sa,
                                  string &value_out)
{
    vector<logline_value>::iterator iter, shift_iter;
    vector<logline_value> &values = *ec.ec_line_values;

    value_out.assign(line.get_data(), line.length());

    for (iter = values.begin(); iter != values.end(); ++iter) {
        if (!iter->lv_origin.is_valid()) {
            log_debug(""not rewriting value with invalid origin -- %s"", iter->lv_name.get());
            continue;
        }

        auto vd_iter = this->elf_value_defs.find(iter->lv_name);
        if (vd_iter == this->elf_value_defs.end()) {
            log_debug(""not rewriting undefined value -- %s"", iter->lv_name.get());
            continue;
        }

        value_def &vd = *vd_iter->second;

        if (vd.vd_rewriter.empty()) {
            continue;
        }

        ec.ec_source.emplace(this->elf_name.to_string() +
                             "":"" +
                             vd_iter->first.to_string(),
                             1);
        string field_value = execute_any(ec, vd.vd_rewriter);
        struct line_range adj_origin = iter->origin_in_full_msg(
            value_out.c_str(), value_out.length());

        value_out.erase(adj_origin.lr_start, adj_origin.length());

        int32_t shift_amount = field_value.length() - adj_origin.length();
        value_out.insert(adj_origin.lr_start, field_value);
        for (shift_iter = values.begin();
             shift_iter != values.end(); ++shift_iter) {
            shift_iter->lv_origin.shift(adj_origin.lr_start, shift_amount);
        }
        shift_string_attrs(sa, adj_origin.lr_start, shift_amount);
    }
}

static int read_json_field(yajlpp_parse_context *ypc, const unsigned char *str, size_t len)
{
    json_log_userdata *jlu = (json_log_userdata *)ypc->ypc_userdata;
    const intern_string_t field_name = ypc->get_path();
    struct exttm tm_out;
    struct timeval tv_out;

    if (jlu->jlu_format->lf_timestamp_field == field_name) {
        jlu->jlu_format->lf_date_time.scan((const char *)str, len, jlu->jlu_format->get_timestamp_formats(), &tm_out, tv_out);
        // Leave off the machine oriented flag since we convert it anyhow
        jlu->jlu_format->lf_timestamp_flags = tm_out.et_flags & ~ETF_MACHINE_ORIENTED;
        jlu->jlu_base_line->set_time(tv_out);
    }
    else if (jlu->jlu_format->elf_level_field == field_name) {
        pcre_input pi((const char *) str, 0, len);
        pcre_context::capture_t level_cap = {0, (int) len};

        jlu->jlu_base_line->set_level(jlu->jlu_format->convert_level(pi, &level_cap));
    }
    else if (jlu->jlu_format->elf_opid_field == field_name) {
        uint8_t opid = hash_str((const char *) str, len);
        jlu->jlu_base_line->set_opid(opid);
    }

    jlu->jlu_sub_line_count += jlu->jlu_format->value_line_count(
        field_name, ypc->is_level(1), str, len);

    return 1;
}

static int rewrite_json_field(yajlpp_parse_context *ypc, const unsigned char *str, size_t len)
{
    static const intern_string_t body_name = intern_string::lookup(""body"", -1);
    json_log_userdata *jlu = (json_log_userdata *)ypc->ypc_userdata;
    const intern_string_t field_name = ypc->get_path();

    if (jlu->jlu_format->lf_timestamp_field == field_name) {
        char time_buf[64];

        // TODO add a timeval kind to logline_value
        if (jlu->jlu_line->is_time_skewed()) {
            struct timeval tv;
            struct exttm tm;

            jlu->jlu_format->lf_date_time.scan((const char *) str, len,
                                               jlu->jlu_format->get_timestamp_formats(),
                                               &tm, tv);
            sql_strftime(time_buf, sizeof(time_buf), tv, 'T');
        }
        else {
            sql_strftime(time_buf, sizeof(time_buf),
                         jlu->jlu_line->get_timeval(), 'T');
        }
        tmp_shared_buffer tsb(time_buf);
        jlu->jlu_format->jlf_line_values.emplace_back(field_name, tsb.tsb_ref);
    }
    else if (jlu->jlu_shared_buffer.contains((const char *)str)) {
        shared_buffer_ref sbr;

        sbr.subset(jlu->jlu_shared_buffer,
                (off_t) ((const char *)str - jlu->jlu_line_value),
                len);
        if (field_name == jlu->jlu_format->elf_body_field) {
            jlu->jlu_format->jlf_line_values.emplace_back(body_name, sbr);
        }
        if (!ypc->is_level(1) && !jlu->jlu_format->has_value_def(field_name)) {
            return 1;
        }

        jlu->jlu_format->jlf_line_values.emplace_back(field_name, sbr);
    }
    else {
        tmp_shared_buffer tsb((const char *)str, len);

        if (field_name == jlu->jlu_format->elf_body_field) {
            jlu->jlu_format->jlf_line_values.emplace_back(body_name, tsb.tsb_ref);
        }
        if (!ypc->is_level(1) && !jlu->jlu_format->has_value_def(field_name)) {
            return 1;
        }

        jlu->jlu_format->jlf_line_values.emplace_back(field_name, tsb.tsb_ref);
    }

    return 1;
}

void external_log_format::get_subline(const logline &ll, shared_buffer_ref &sbr, bool full_message)
{
    if (this->elf_type == ELF_TYPE_TEXT) {
        return;
    }

    if (this->jlf_cached_offset != ll.get_offset() ||
        this->jlf_cached_full != full_message) {
        yajlpp_parse_context &ypc = *(this->jlf_parse_context);
        yajl_handle handle = this->jlf_yajl_handle.in();
        json_log_userdata jlu(sbr);

        this->jlf_share_manager.invalidate_refs();
        this->jlf_cached_line.clear();
        this->jlf_line_values.clear();
        this->jlf_line_offsets.clear();
        this->jlf_line_attrs.clear();

        yajl_reset(handle);
        ypc.set_static_handler(json_log_rewrite_handlers[0]);
        ypc.ypc_userdata = &jlu;
        ypc.ypc_ignore_unused = true;
        ypc.ypc_alt_callbacks.yajl_start_array = json_array_start;
        ypc.ypc_alt_callbacks.yajl_end_array = json_array_end;
        ypc.ypc_alt_callbacks.yajl_start_map = json_array_start;
        ypc.ypc_alt_callbacks.yajl_end_map = json_array_end;
        jlu.jlu_format = this;
        jlu.jlu_line = &ll;
        jlu.jlu_handle = handle;
        jlu.jlu_line_value = sbr.get_data();

        yajl_status parse_status = yajl_parse(handle,
            (const unsigned char *)sbr.get_data(), sbr.length());
        if (parse_status == yajl_status_ok &&
            yajl_complete_parse(handle) == yajl_status_ok) {
            std::vector<logline_value>::iterator lv_iter;
            bool used_values[this->jlf_line_values.size()];
            struct line_range lr;

            memset(used_values, 0, sizeof(used_values));

            for (lv_iter = this->jlf_line_values.begin();
                 lv_iter != this->jlf_line_values.end();
                 ++lv_iter) {
                lv_iter->lv_format = this;
                auto vd_iter = this->elf_value_defs.find(lv_iter->lv_name);
                if (vd_iter != this->elf_value_defs.end()) {
                    lv_iter->lv_identifier = vd_iter->second->vd_identifier;
                    lv_iter->lv_column = vd_iter->second->vd_column;
                    lv_iter->lv_hidden = vd_iter->second->vd_hidden;
                    lv_iter->lv_user_hidden = vd_iter->second->vd_user_hidden;
                } else {
                    lv_iter->lv_hidden = this->jlf_hide_extra;
                }
            }

            for (const auto &jfe : this->jlf_line_format) {
                static const intern_string_t ts_field = intern_string::lookup(""__timestamp__"", -1);
                static const intern_string_t level_field = intern_string::lookup(""__level__"");
                size_t begin_size = this->jlf_cached_line.size();

                switch (jfe.jfe_type) {
                case JLF_CONSTANT:
                    this->json_append_to_cache(jfe.jfe_default_value.c_str(),
                            jfe.jfe_default_value.size());
                    break;
                case JLF_VARIABLE:
                    lv_iter = find_if(this->jlf_line_values.begin(),
                                      this->jlf_line_values.end(),
                                      logline_value_cmp(&jfe.jfe_value));
                    if (lv_iter != this->jlf_line_values.end()) {
                        string str = lv_iter->to_string();
                        size_t nl_pos = str.find('\\n');

                        lr.lr_start = this->jlf_cached_line.size();

                        lv_iter->lv_hidden = lv_iter->lv_user_hidden;
                        if ((int)str.size() > jfe.jfe_max_width) {
                            switch (jfe.jfe_overflow) {
                                case json_format_element::overflow_t::ABBREV: {
                                    this->json_append_to_cache(
                                        str.c_str(), str.size());
                                    size_t new_size = abbreviate_str(
                                        &this->jlf_cached_line[lr.lr_start],
                                        str.size(),
                                        jfe.jfe_max_width);

                                    this->jlf_cached_line.resize(
                                        lr.lr_start + new_size);
                                    break;
                                }
                                case json_format_element::overflow_t::TRUNCATE: {
                                    this->json_append_to_cache(
                                        str.c_str(), jfe.jfe_max_width);
                                    break;
                                }
                                case json_format_element::overflow_t::DOTDOT: {
                                    size_t middle = (jfe.jfe_max_width / 2) - 1;
                                    this->json_append_to_cache(
                                        str.c_str(), middle);
                                    this->json_append_to_cache("".."", 2);
                                    size_t rest = (jfe.jfe_max_width - middle - 2);
                                    this->json_append_to_cache(
                                        str.c_str() + str.size() - rest, rest);
                                    break;
                                }
                            }
                        }
                        else {
                            this->json_append(jfe, str.c_str(), str.size());
                        }

                        if (nl_pos == string::npos || full_message) {
                            lr.lr_end = this->jlf_cached_line.size();
                        } else {
                            lr.lr_end = lr.lr_start + nl_pos;
                        }

                        if (lv_iter->lv_name == this->lf_timestamp_field) {
                            this->jlf_line_attrs.push_back(
                                string_attr(lr, &logline::L_TIMESTAMP));
                        }
                        else if (lv_iter->lv_name == this->elf_body_field) {
                            this->jlf_line_attrs.push_back(
                                string_attr(lr, &textview_curses::SA_BODY));
                        }
                        else if (lv_iter->lv_name == this->elf_opid_field) {
                            this->jlf_line_attrs.push_back(
                                    string_attr(lr, &logline::L_OPID));
                        }
                        lv_iter->lv_origin = lr;
                        used_values[distance(this->jlf_line_values.begin(),
                                             lv_iter)] = true;
                    }
                    else if (jfe.jfe_value == ts_field) {
                        struct line_range lr;
                        ssize_t ts_len;
                        char ts[64];

                        if (jfe.jfe_ts_format.empty()) {
                            ts_len = sql_strftime(ts, sizeof(ts),
                                                  ll.get_timeval(), 'T');
                        } else {
                            struct exttm et;

                            ll.to_exttm(et);
                            ts_len = ftime_fmt(ts, sizeof(ts),
                                               jfe.jfe_ts_format.c_str(),
                                               et);
                        }
                        lr.lr_start = this->jlf_cached_line.size();
                        this->json_append_to_cache(ts, ts_len);
                        lr.lr_end = this->jlf_cached_line.size();
                        this->jlf_line_attrs.emplace_back(lr, &logline::L_TIMESTAMP);

                        lv_iter = find_if(this->jlf_line_values.begin(),
                                          this->jlf_line_values.end(),
                                          logline_value_cmp(&this->lf_timestamp_field));
                        if (lv_iter != this->jlf_line_values.end()) {
                            used_values[distance(this->jlf_line_values.begin(),
                                                 lv_iter)] = true;
                        }
                    }
                    else if (jfe.jfe_value == level_field) {
                        this->json_append(jfe, ll.get_level_name(), -1);
                    }
                    else {
                        this->json_append(jfe,
                                          jfe.jfe_default_value.c_str(),
                                          jfe.jfe_default_value.size());
                    }

                    switch (jfe.jfe_text_transform) {
                        case external_log_format::json_format_element::transform_t::NONE:
                            break;
                        case external_log_format::json_format_element::transform_t::UPPERCASE:
                            for (size_t cindex = begin_size; cindex < this->jlf_cached_line.size(); cindex++) {
                                this->jlf_cached_line[cindex] = toupper(this->jlf_cached_line[cindex]);
                            }
                            break;
                        case external_log_format::json_format_element::transform_t::LOWERCASE:
                            for (size_t cindex = begin_size; cindex < this->jlf_cached_line.size(); cindex++) {
                                this->jlf_cached_line[cindex] = tolower(this->jlf_cached_line[cindex]);
                            }
                            break;
                        case external_log_format::json_format_element::transform_t::CAPITALIZE:
                            for (size_t cindex = begin_size; cindex < begin_size + 1; cindex++) {
                                this->jlf_cached_line[cindex] = toupper(this->jlf_cached_line[cindex]);
                            }
                            for (size_t cindex = begin_size + 1; cindex < this->jlf_cached_line.size(); cindex++) {
                                this->jlf_cached_line[cindex] = tolower(this->jlf_cached_line[cindex]);
                            }
                            break;
                    }
                    break;
                }
            }
            this->json_append_to_cache(""\\n"", 1);
            int sub_offset = 1;

            for (size_t lpc = 0; lpc < this->jlf_line_values.size(); lpc++) {
                static const intern_string_t body_name = intern_string::lookup(
                    ""body"", -1);
                logline_value &lv = this->jlf_line_values[lpc];

                if (lv.lv_hidden || used_values[lpc] || body_name == lv.lv_name) {
                    continue;
                }

                const std::string str = lv.to_string();
                size_t curr_pos = 0, nl_pos, line_len = -1;

                lv.lv_sub_offset = sub_offset;
                lv.lv_origin.lr_start = 2 + lv.lv_name.size() + 2;
                do {
                    nl_pos = str.find('\\n', curr_pos);
                    if (nl_pos != std::string::npos) {
                        line_len = nl_pos - curr_pos;
                    }
                    else {
                        line_len = str.size() - curr_pos;
                    }
                    this->json_append_to_cache(""  "", 2);
                    this->json_append_to_cache(lv.lv_name.get(),
                                               lv.lv_name.size());
                    this->json_append_to_cache("": "", 2);
                    this->json_append_to_cache(
                        &str.c_str()[curr_pos], line_len);
                    this->json_append_to_cache(""\\n"", 1);
                    curr_pos = nl_pos + 1;
                    sub_offset += 1;
                } while (nl_pos != std::string::npos &&
                         nl_pos < str.size());
            }

            this->jlf_line_offsets.push_back(0);
            for (size_t lpc = 0; lpc < this->jlf_cached_line.size(); lpc++) {
                if (this->jlf_cached_line[lpc] == '\\n') {
                    this->jlf_line_offsets.push_back(lpc);
                }
            }
            this->jlf_line_offsets.push_back(this->jlf_cached_line.size());
        }

        this->jlf_cached_offset = ll.get_offset();
        this->jlf_cached_full = full_message;
    }

    off_t this_off = 0, next_off = 0;

    if (!this->jlf_line_offsets.empty()) {
        require(ll.get_sub_offset() < this->jlf_line_offsets.size());

        this_off = this->jlf_line_offsets[ll.get_sub_offset()];
        if (this->jlf_cached_line[this_off] == '\\n') {
            this_off += 1;
        }
        if ((ll.get_sub_offset() + 1) < (int)this->jlf_line_offsets.size()) {
            next_off = this->jlf_line_offsets[ll.get_sub_offset() + 1];
        }
        else {
            next_off = this_off;
        }
    }

    if (full_message) {
        sbr.share(this->jlf_share_manager,
                  &this->jlf_cached_line[0],
                  this->jlf_cached_line.size());
    }
    else {
        sbr.share(this->jlf_share_manager,
                  &this->jlf_cached_line[0] + this_off,
                  next_off - this_off);
    }
}

void external_log_format::build(std::vector<std::string> &errors) {
    if (!this->lf_timestamp_field.empty()) {
        auto &vd = this->elf_value_defs[this->lf_timestamp_field];
        if (vd.get() == nullptr) {
            vd = make_shared<external_log_format::value_def>();
        }
        vd->vd_name = this->lf_timestamp_field;
        vd->vd_kind = logline_value::VALUE_TEXT;
        vd->vd_internal = true;
    }
    if (!this->elf_level_field.empty() && this->elf_value_defs.
        find(this->elf_level_field) == this->elf_value_defs.end()) {
        auto &vd = this->elf_value_defs[this->elf_level_field];
        if (vd.get() == nullptr) {
            vd = make_shared<external_log_format::value_def>();
        }
        vd->vd_name = this->elf_level_field;
        vd->vd_kind = logline_value::VALUE_TEXT;
        vd->vd_internal = true;
    }
    if (!this->elf_body_field.empty()) {
        auto &vd = this->elf_value_defs[this->elf_body_field];
        if (vd.get() == nullptr) {
            vd = make_shared<external_log_format::value_def>();
        }
        vd->vd_name = this->elf_body_field;
        vd->vd_kind = logline_value::VALUE_TEXT;
        vd->vd_internal = true;
    }

    if (!this->lf_timestamp_format.empty()) {
        this->lf_timestamp_format.push_back(NULL);
    }
    try {
        this->elf_filename_pcre = new pcrepp(this->elf_file_pattern);
    }
    catch (const pcrepp::error &e) {
        errors.push_back(""error:"" +
                         this->elf_name.to_string() + "".file-pattern:"" +
                         e.what());
    }
    for (auto iter = this->elf_patterns.begin();
         iter != this->elf_patterns.end();
         ++iter) {
        pattern &pat = *iter->second;

        if (pat.p_module_format) {
            this->elf_has_module_format = true;
        }

        try {
            pat.p_pcre = new pcrepp(pat.p_string);
        }
        catch (const pcrepp::error &e) {
            errors.push_back(""error:"" +
                             this->elf_name.to_string() + "".regex["" +
                             iter->first + ""]"" +
                             "":"" +
                             e.what());
            errors.push_back(""error:"" +
                             this->elf_name.to_string() + "".regex["" +
                             iter->first + ""]"" +
                             "":"" + pat.p_string);
            errors.push_back(""error:"" +
                             this->elf_name.to_string() + "".regex["" +
                             iter->first + ""]"" +
                             "":"" + string(e.e_offset, ' ') +
                             ""^"");
            continue;
        }
        for (pcre_named_capture::iterator name_iter = pat.p_pcre->named_begin();
             name_iter != pat.p_pcre->named_end();
             ++name_iter) {
            const intern_string_t name = intern_string::lookup(
                name_iter->pnc_name, -1);

            if (name == this->lf_timestamp_field) {
                pat.p_timestamp_field_index = name_iter->index();
            }
            if (name == this->elf_level_field) {
                pat.p_level_field_index = name_iter->index();
            }
            if (name == this->elf_module_id_field) {
                pat.p_module_field_index = name_iter->index();
            }
            if (name == this->elf_opid_field) {
                pat.p_opid_field_index = name_iter->index();
            }
            if (name == this->elf_body_field) {
                pat.p_body_field_index = name_iter->index();
            }

            auto value_iter = this->elf_value_defs.find(name);
            if (value_iter != this->elf_value_defs.end()) {
                auto &vd = *value_iter->second;
                indexed_value_def ivd;

                ivd.ivd_index = name_iter->index();
                if (!vd.vd_unit_field.empty()) {
                    ivd.ivd_unit_field_index = pat.p_pcre->name_index(
                        vd.vd_unit_field.get());
                }
                else {
                    ivd.ivd_unit_field_index = -1;
                }
                if (!vd.vd_internal && vd.vd_column == -1) {
                    vd.vd_column = this->elf_column_count++;
                }
                ivd.ivd_value_def = value_iter->second.get();
                pat.p_value_by_index.push_back(ivd);
            }
        }

        stable_sort(pat.p_value_by_index.begin(), pat.p_value_by_index.end());

        for (int lpc = 0; lpc < (int)pat.p_value_by_index.size(); lpc++) {
            auto &ivd = pat.p_value_by_index[lpc];
            auto &vd = *ivd.ivd_value_def;

            if (!vd.vd_foreign_key && !vd.vd_identifier) {
                switch (vd.vd_kind) {
                    case logline_value::VALUE_INTEGER:
                    case logline_value::VALUE_FLOAT:
                        pat.p_numeric_value_indexes.push_back(lpc);
                        break;
                    default:
                        break;
                }
            }
        }

        if (!this->elf_level_field.empty() && pat.p_level_field_index == -1) {
            log_warning(""%s:level field '%s' not found in pattern"",
                        pat.p_config_path.c_str(),
                        this->elf_level_field.get());
        }
        if (!this->elf_module_id_field.empty() &&
            pat.p_module_field_index == -1) {
            log_warning(""%s:module field '%s' not found in pattern"",
                        pat.p_config_path.c_str(),
                        this->elf_module_id_field.get());
        }
        if (!this->elf_body_field.empty() && pat.p_body_field_index == -1) {
            log_warning(""%s:body field '%s' not found in pattern"",
                        pat.p_config_path.c_str(),
                        this->elf_body_field.get());
        }

        this->elf_pattern_order.push_back(iter->second);
    }

    if (this->elf_type != ELF_TYPE_TEXT) {
        if (!this->elf_patterns.empty()) {
            errors.push_back(""error:"" +
                             this->elf_name.to_string() +
                             "": structured logs cannot have regexes"");
        }
        if (this->elf_type == ELF_TYPE_JSON) {
            this->jlf_parse_context.reset(
                new yajlpp_parse_context(this->elf_name.to_string()));
            this->jlf_yajl_handle.reset(yajl_alloc(
                &this->jlf_parse_context->ypc_callbacks,
                NULL,
                this->jlf_parse_context.get()));
            yajl_config(this->jlf_yajl_handle.in(), yajl_dont_validate_strings,
                        1);
        }

    }
    else {
        if (this->elf_patterns.empty()) {
            errors.push_back(""error:"" +
                             this->elf_name.to_string() +
                             "": no regexes specified for format"");
        }
    }

    for (auto &elf_level_pattern : this->elf_level_patterns) {
        try {
            elf_level_pattern.second.lp_pcre = new pcrepp(
                elf_level_pattern.second.lp_regex.c_str());
        }
        catch (const pcrepp::error &e) {
            errors.push_back(""error:"" +
                             this->elf_name.to_string() + "".level:"" + e.what());
        }
    }

    stable_sort(this->elf_level_pairs.begin(), this->elf_level_pairs.end());

    for (auto &elf_value_def : this->elf_value_defs) {
        std::vector<std::string>::iterator act_iter;

        if (!elf_value_def.second->vd_internal &&
            elf_value_def.second->vd_column == -1) {
            elf_value_def.second->vd_column = this->elf_column_count++;
        }

        if (elf_value_def.second->vd_kind == logline_value::VALUE_UNKNOWN) {
            elf_value_def.second->vd_kind = logline_value::VALUE_TEXT;
        }

        for (act_iter = elf_value_def.second->vd_action_list.begin();
             act_iter != elf_value_def.second->vd_action_list.end();
             ++act_iter) {
            if (this->lf_action_defs.find(*act_iter) ==
                this->lf_action_defs.end()) {
                errors.push_back(""error:"" +
                                 this->elf_name.to_string() + "":"" +
                                     elf_value_def.first.get() +
                                 "": cannot find action -- "" + (*act_iter));
            }
        }
    }

    if (this->elf_type == ELF_TYPE_TEXT && this->elf_samples.empty()) {
        errors.push_back(""error:"" +
                         this->elf_name.to_string() +
                         "":no sample logs provided, all formats must have samples"");
    }

    for (auto &elf_sample : this->elf_samples) {
        pcre_context_static<128> pc;
        pcre_input pi(elf_sample.s_line);
        bool found = false;

        for (auto pat_iter = this->elf_pattern_order.begin();
             pat_iter != this->elf_pattern_order.end() && !found;
             ++pat_iter) {
            pattern &pat = *(*pat_iter);

            if (!pat.p_pcre) {
                continue;
            }

            if (!pat.p_module_format &&
                pat.p_pcre->name_index(this->lf_timestamp_field.to_string()) <
                0) {
                errors.push_back(""error:"" +
                                 this->elf_name.to_string() +
                                 "":timestamp field '"" +
                                 this->lf_timestamp_field.get() +
                                 ""' not found in pattern -- "" +
                                 pat.p_string);
                continue;
            }

            if (pat.p_pcre->match(pc, pi)) {
                if (pat.p_module_format) {
                    found = true;
                    continue;
                }
                pcre_context::capture_t *ts_cap =
                    pc[this->lf_timestamp_field.get()];
                pcre_context::capture_t *level_cap = pc[pat.p_level_field_index];
                const char *ts = pi.get_substr_start(ts_cap);
                ssize_t ts_len = pc[this->lf_timestamp_field.get()]->length();
                const char *const *custom_formats = this->get_timestamp_formats();
                date_time_scanner dts;
                struct timeval tv;
                struct exttm tm;

                if (ts_cap->c_begin == 0) {
                    pat.p_timestamp_end = ts_cap->c_end;
                }
                found = true;
                if (ts_len == -1 ||
                    dts.scan(ts, ts_len, custom_formats, &tm, tv) == NULL) {
                    errors.push_back(""error:"" +
                                     this->elf_name.to_string() +
                                     "":invalid sample -- "" +
                                         elf_sample.s_line);
                    errors.push_back(""error:"" +
                                     this->elf_name.to_string() +
                                     "":unrecognized timestamp format -- "" + ts);

                    if (custom_formats == NULL) {
                        for (int lpc = 0;
                             PTIMEC_FORMATS[lpc].pf_fmt != NULL; lpc++) {
                            off_t off = 0;

                            PTIMEC_FORMATS[lpc].pf_func(&tm, ts, off, ts_len);
                            errors.push_back(""  format: "" +
                                             string(
                                                 PTIMEC_FORMATS[lpc].pf_fmt) +
                                             ""; matched: "" + string(ts, off));
                        }
                    }
                    else {
                        for (int lpc = 0; custom_formats[lpc] != NULL; lpc++) {
                            off_t off = 0;

                            ptime_fmt(custom_formats[lpc], &tm, ts, off,
                                      ts_len);
                            errors.push_back(""  format: "" +
                                             string(custom_formats[lpc]) +
                                             ""; matched: "" + string(ts, off));
                        }
                    }
                }

                log_level_t level = this->convert_level(pi, level_cap);

                if (elf_sample.s_level != LEVEL_UNKNOWN) {
                    if (elf_sample.s_level != level) {
                        errors.push_back(""error:"" +
                                         this->elf_name.to_string() +
                                         "":invalid sample -- "" +
                                             elf_sample.s_line);
                        errors.push_back(""error:"" +
                                         this->elf_name.to_string() +
                                         "":parsed level '"" +
                                         level_names[level] +
                                         ""' does not match expected level of '"" +
                                         level_names[elf_sample.s_level] +
                                         ""'"");
                    }
                }
            }
        }

        if (!found) {
            errors.push_back(""error:"" +
                             this->elf_name.to_string() +
                             "":invalid sample         -- "" +
                                 elf_sample.s_line);

            for (auto pat_iter = this->elf_pattern_order.begin();
                 pat_iter != this->elf_pattern_order.end();
                 ++pat_iter) {
                pattern &pat = *(*pat_iter);

                if (!pat.p_pcre) {
                    continue;
                }

                size_t partial_len = pat.p_pcre->match_partial(pi);

                if (partial_len > 0) {
                    errors.push_back(""error:"" +
                                     this->elf_name.to_string() +
                                     "":partial sample matched -- "" +
                                         elf_sample.s_line.substr(0, partial_len));
                    errors.push_back(""error:  against pattern -- "" +
                                     (*pat_iter)->p_string);
                }
                else {
                    errors.push_back(""error:"" +
                                     this->elf_name.to_string() +
                                     "":no partial match found"");
                }
            }
        }
    }

    for (auto &elf_value_def : this->elf_value_defs) {
        if (elf_value_def.second->vd_foreign_key || elf_value_def.second->vd_identifier) {
            continue;
        }

        switch (elf_value_def.second->vd_kind) {
            case logline_value::VALUE_INTEGER:
            case logline_value::VALUE_FLOAT:
                elf_value_def.second->vd_values_index = this->elf_numeric_value_defs.size();
                this->elf_numeric_value_defs.push_back(elf_value_def.second);
                break;
            default:
                break;
        }
    }

    this->lf_value_stats.resize(this->elf_numeric_value_defs.size());

    int format_index = 0;
    for (auto iter = this->jlf_line_format.begin();
         iter != this->jlf_line_format.end();
         ++iter, format_index++) {
        static const intern_string_t ts = intern_string::lookup(""__timestamp__"");
        static const intern_string_t level_field = intern_string::lookup(""__level__"");
        json_format_element &jfe = *iter;

        if (jfe.jfe_value.empty() && !jfe.jfe_ts_format.empty()) {
            jfe.jfe_value = ts;
        }

        switch (jfe.jfe_type) {
            case JLF_VARIABLE: {
                auto vd_iter = this->elf_value_defs.find(jfe.jfe_value);
                if (jfe.jfe_value == ts) {
                    this->elf_value_defs[this->lf_timestamp_field]->vd_hidden = true;
                } else if (jfe.jfe_value == level_field) {
                    this->elf_value_defs[this->elf_level_field]->vd_hidden = true;
                } else if (vd_iter == this->elf_value_defs.end()) {
                    char index_str[32];

                    snprintf(index_str, sizeof(index_str), ""%d"", format_index);
                    errors.push_back(""error:"" +
                                     this->elf_name.to_string() +
                                     "":line_format["" +
                                     index_str +
                                     ""]:line format variable is not defined -- "" +
                                     jfe.jfe_value.to_string());
                }
                break;
            }
            default:
                break;
        }
    }

    for (auto &hd_pair : this->elf_highlighter_patterns) {
        external_log_format::highlighter_def &hd = hd_pair.second;
        const std::string &pattern = hd.hd_pattern;
        std::string errmsg;
        const char *errptr;
        rgb_color fg, bg;
        int eoff, attrs = 0;

        if (!hd.hd_color.empty()) {
            if (!rgb_color::from_str(hd.hd_color, fg, errmsg)) {
                errors.push_back(""error:""
                                 + this->elf_name.to_string()
                                 + "":highlighters/""
                                 + hd_pair.first.to_string()
                                 + ""/color:""
                                 + errmsg);
            }
        }

        if (!hd.hd_background_color.empty()) {
            if (!rgb_color::from_str(hd.hd_background_color, bg, errmsg)) {
                errors.push_back(""error:""
                                 + this->elf_name.to_string()
                                 + "":highlighters/""
                                 + hd_pair.first.to_string()
                                 + ""/color:""
                                 + errmsg);
            }
        }

        if (hd.hd_underline) {
            attrs |= A_UNDERLINE;
        }
        if (hd.hd_blink) {
            attrs |= A_BLINK;
        }

        pcre *code = pcre_compile(pattern.c_str(),
                                  0,
                                  &errptr,
                                  &eoff,
                                  nullptr);

        if (code == nullptr) {
            errors.push_back(""error:""
                             + this->elf_name.to_string()
                             + "":highlighters/""
                             + hd_pair.first.to_string()
                             + "":""
                             + string(errptr));
            errors.push_back(""error:""
                             + this->elf_name.to_string()
                             + "":highlighters/""
                             + hd_pair.first.to_string()
                             + "":""
                             + pattern);
            errors.push_back(""error:""
                             + this->elf_name.to_string()
                             + "":highlighters/""
                             + hd_pair.first.to_string()
                             + "":""
                             + string(eoff, ' ')
                             + ""^"");
        } else {
            this->lf_highlighters.emplace_back(code);
            this->lf_highlighters.back()
                .with_pattern(pattern)
                .with_format_name(this->elf_name)
                .with_color(fg, bg)
                .with_attrs(attrs);
        }
    }
}

void external_log_format::register_vtabs(log_vtab_manager *vtab_manager,
                                         std::vector<std::string> &errors)
{
    vector<pair<intern_string_t, string> >::iterator search_iter;
    for (search_iter = this->elf_search_tables.begin();
         search_iter != this->elf_search_tables.end();
         ++search_iter) {
        log_search_table *lst;

        try {
            lst = new log_search_table(search_iter->second.c_str(), search_iter->first);
        } catch (pcrepp::error &e) {
            errors.push_back(
                    ""error:"" +
                    this->elf_name.to_string() +
                    "":"" +
                    search_iter->first.to_string() +
                    "":unable to compile regex -- "" +
                    search_iter->second);
            continue;
        }

        string errmsg;

        errmsg = vtab_manager->register_vtab(lst);
        if (!errmsg.empty()) {
            errors.push_back(
                ""error:"" +
                this->elf_name.to_string() +
                "":"" +
                search_iter->first.to_string() +
                "":unable to register table -- "" +
                errmsg);
        }
    }
}

bool external_log_format::match_samples(const vector<sample> &samples) const
{
    for (const auto &sample_iter : samples) {
        for (const auto &pat_iter : this->elf_pattern_order) {
            pattern &pat = *pat_iter;

            if (!pat.p_pcre) {
                continue;
            }

            pcre_context_static<128> pc;
            pcre_input pi(sample_iter.s_line);

            if (pat.p_pcre->match(pc, pi)) {
                return true;
            }
        }
    }

    return false;
}

class external_log_table : public log_format_vtab_impl {
public:
    external_log_table(const external_log_format &elf) :
        log_format_vtab_impl(elf), elt_format(elf) {
    };

    void get_columns(vector<vtab_column> &cols) const {
        const external_log_format &elf = this->elt_format;

        cols.resize(elf.elf_column_count);
        for (const auto &elf_value_def : elf.elf_value_defs) {
            const auto &vd = *elf_value_def.second;
            pair<int, unsigned int> type_pair = log_vtab_impl::logline_value_to_sqlite_type(vd.vd_kind);

            if (vd.vd_column == -1) {
                continue;
            }

            cols[vd.vd_column].vc_name = vd.vd_name.get();
            cols[vd.vd_column].vc_type = type_pair.first;
            cols[vd.vd_column].vc_subtype = type_pair.second;
            cols[vd.vd_column].vc_collator = vd.vd_collate.c_str();
            cols[vd.vd_column].vc_comment = vd.vd_description;
        }
    };

    void get_foreign_keys(std::vector<std::string> &keys_inout) const
    {
        log_vtab_impl::get_foreign_keys(keys_inout);

        for (const auto &elf_value_def : this->elt_format.elf_value_defs) {
            if (elf_value_def.second->vd_foreign_key) {
                keys_inout.push_back(elf_value_def.first.to_string());
            }
        }
    };

    virtual bool next(log_cursor &lc, logfile_sub_source &lss)
    {
        lc.lc_curr_line = lc.lc_curr_line + vis_line_t(1);
        lc.lc_sub_index = 0;

        if (lc.is_eof()) {
            return true;
        }

        content_line_t    cl(lss.at(lc.lc_curr_line));
        shared_ptr<logfile> lf = lss.find(cl);
        auto lf_iter = lf->begin() + cl;
        uint8_t mod_id = lf_iter->get_module_id();

        if (lf_iter->is_continued()) {
            return false;
        }

        log_format *format = lf->get_format();

        this->elt_module_format.mf_mod_format = nullptr;
        if (format->get_name() == this->lfvi_format.get_name()) {
            return true;
        } else if (mod_id && mod_id == this->lfvi_format.lf_mod_index) {
            std::vector<logline_value> values;
            shared_buffer_ref body_ref;
            struct line_range mod_name_range;
            intern_string_t mod_name;
            shared_buffer_ref line;

            lf->read_line(lf_iter, line);
            this->vi_attrs.clear();
            format->annotate(cl, line, this->vi_attrs, values, false);
            this->elt_container_body = find_string_attr_range(this->vi_attrs, &textview_curses::SA_BODY);
            if (!this->elt_container_body.is_valid()) {
                return false;
            }
            this->elt_container_body.ltrim(line.get_data());
            body_ref.subset(line,
                            this->elt_container_body.lr_start,
                            this->elt_container_body.length());
            mod_name_range = find_string_attr_range(this->vi_attrs,
                                                    &logline::L_MODULE);
            if (!mod_name_range.is_valid()) {
                return false;
            }
            mod_name = intern_string::lookup(
                    &line.get_data()[mod_name_range.lr_start],
                    mod_name_range.length());
            this->vi_attrs.clear();
            this->elt_module_format = external_log_format::MODULE_FORMATS[mod_name];
            if (!this->elt_module_format.mf_mod_format) {
                return false;
            }
            return this->elt_module_format.mf_mod_format->get_name() ==
                    this->lfvi_format.get_name();
        }

        return false;
    };

    virtual void extract(shared_ptr<logfile> lf,
                         uint64_t line_number,
                         shared_buffer_ref &line,
                         std::vector<logline_value> &values)
    {
        log_format *format = lf->get_format();

        if (this->elt_module_format.mf_mod_format != nullptr) {
            shared_buffer_ref body_ref;

            body_ref.subset(line, this->elt_container_body.lr_start,
                            this->elt_container_body.length());
            this->vi_attrs.clear();
            values.clear();
            this->elt_module_format.mf_mod_format->annotate(line_number,
                                                            body_ref,
                                                            this->vi_attrs,
                                                            values,
                                                            false);
        }
        else {
            this->vi_attrs.clear();
            format->annotate(line_number, line, this->vi_attrs, values, false);
        }
    };

    const external_log_format &elt_format;
    module_format elt_module_format;
    struct line_range elt_container_body;
};

log_vtab_impl *external_log_format::get_vtab_impl() const
{
    return new external_log_table(*this);
}

int log_format::pattern_index_for_line(uint64_t line_number) const
{
    auto iter = lower_bound(this->lf_pattern_locks.cbegin(),
                            this->lf_pattern_locks.cend(),
                            line_number,
                            [](const pattern_for_lines &pfl, uint32_t line) {
        return pfl.pfl_line < line;
    });

    if (iter == this->lf_pattern_locks.end() ||
        iter->pfl_line != line_number) {
        --iter;
    }

    return iter->pfl_pat_index;
}

log_format::pattern_for_lines::pattern_for_lines(
    uint32_t pfl_line, uint32_t pfl_pat_index) :
    pfl_line(pfl_line), pfl_pat_index(pfl_pat_index)
{
}

/* XXX */
#include ""log_format_impls.cc""
",16133,True,3258.547101986733,median
"/*
  MIT License
Version 1.0 2018-12-14
Copyright (c) 2018 kaebmoo gmail 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.
*/


/*
 * Hardware
 * Wemos D1 mini, Pro (esp8266)
 * soilWatch 10 use A1, A2, A3 pin
 * Wemos Relay Shield use D4,D5,D6 pin
 *
 *
 *
 */

#include <ESP8266WiFi.h>          //https://github.com/esp8266/Arduino
#include <DNSServer.h>            //Local DNS Server used for redirecting all requests to the configuration portal
#include <ESP8266WebServer.h>     //Local WebServer used to serve the configuration portal
#include <WiFiManager.h>          //https://github.com/tzapu/WiFiManager WiFi Configuration Magic
#include <ESP8266WiFiMulti.h>

#include <WiFiClient.h>
#include <ESP8266mDNS.h>
#include <ESP8266HTTPUpdateServer.h>
#include <ESP8266HTTPClient.h>
#include <ESP8266httpUpdate.h>

#include <EEPROM.h>
#include <BlynkSimpleEsp8266.h>
#include <ThingSpeak.h>
#include <ArduinoJson.h>
#include <PubSubClient.h>

#include <Wire.h>
#include <Adafruit_ADS1015.h>


#define BLYNKLOCAL
// #define SLEEP
// #define FARMLOCAL
#define THINGSBOARD
// #define THINGSPEAK
#define MULTISENSOR

const int FW_VERSION = 1;  // 2018 12 1 version 1.0
const char* firmwareUrlBase = ""http://www.ogonan.com/ogoupdate/"";

#ifdef ARDUINO_ESP8266_WEMOS_D1MINI
  String firmware_name = ""ogoSwitch_soilMoistureSensor_3CH.ino.d1_mini"";
#elif ARDUINO_ESP8266_WEMOS_D1MINILITE
  String firmware_name = ""ogoSwitch_soilMoistureSensor_3CH.ino.d1_minilite"";
#elif ARDUINO_ESP8266_WEMOS_D1MINIPRO
  String firmware_name = ""ogoSwitch_soilMoistureSensor_3CH.ino.d1_minipro"";
#endif

char thingSpeakAddress[] = ""api.thingspeak.com"";
unsigned long channelID = 360709;
char *readAPIKey = ""GNZ8WEU763Z5DUEA"";
char *writeAPIKey = ""8M07EYX8NPCD9V8U"";

char thingsboardServer[40] = ""thingsboard.ogonan.com"";
int  mqttport = 1883;                      // 1883 or 1888
char token[32] = ""GytOdBkhNbMeHq74561I"";   // device token from thingsboard server

char c_thingsboardServer[41] = ""192.168.1.10"";
char c_mqttport[8] = ""1883"";
char c_token[33] = ""12345678901234567890"";
char c_sendinterval[8] = ""60"";
// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = ""634021991b694e08b004ca8b13f08bc1"";
char c_auth[33] = ""634021991b694e08b004ca8b13f08bc1"";           // authen token blynk
char c_writeAPIKey[17] = """";                                    // write api key thingspeak
char c_sleepSeconds[8] = ""300"";

//flag for saving data
bool shouldSaveConfig = false;
int sendinterval = 60;                                       // send data interval time in second


#define TRIGGER_PIN D3                      // GPIO 0
const int analogReadPin = A0;               // read for set options Soil Moisture or else ...
#ifndef SLEEP
const int RELAY1 = D4;                      // GPIO 5
const int RELAY2 = D5;
const int RELAY3 = D6;
#endif

#ifdef SLEEP
const int RELAY1 = D7;
#endif


#define GPIO0 16                            // D0
#define GPIO2 2                             // D4

#define GPIO0_PIN D0
#define GPIO2_PIN D4
// We assume that all GPIOs are LOW
boolean gpioState[] = {false, false};
const int MAXRETRY=5;

// soil moisture variables
int minADC = 0;                       // replace with min ADC value read in air
int maxADC = 1440;                     // replace with max ADC value read fully submerged in water
int soilMoistureSetPoint =  50;
int soilMoistureSetPoint1 = 50;
int soilMoistureSetPoint2 = 50;
int soilMoistureSetPoint3 = 50;
int soilMoisture, mappedValue, mappedValue1, mappedValue2, mappedValue3;
int range = 20;
int range1 = 20;
int range2 = 20;
int range3 = 20;

unsigned long lastMqttConnectionAttempt = 0;
const long interval = 1000;
int ledState = LOW;
unsigned long previousMillis = 0;

int offline = 0;
BlynkTimer timer, checkConnectionTimer;
WidgetLED led1(20);
WidgetLED led2(21);
WidgetLED led3(22);

char *mqtt_user = ""seal"";
char *mqtt_password = ""sealwiththekiss"";
const char* mqtt_server = ""db.ogonan.com"";


char *myRoom = ""sensor/mySpUo9axZsy36zSgxY0Lm3ZI2DiOJSD"";
char *roomStatus = ""sensor/mySpUo9axZsy36zSgxY0Lm3ZI2DiOJSD/status"";
int mqtt_reconnect = 0;

WiFiClient client;
PubSubClient mqttClient(client);
ESP8266WiFiMulti wifiMulti;
#ifdef SLEEP
  // sleep for this many seconds default is 300 (5 minutes)
  int sleepSeconds = 15;
  Adafruit_ADS1015 ads1015;   // Construct an ads1015 at the default address: 0x48
#endif

#ifdef MULTISENSOR
  Adafruit_ADS1015 ads1015;   // Construct an ads1015 at the default address: 0x48
#endif


void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  pinMode(RELAY1, OUTPUT);
  pinMode(BUILTIN_LED, OUTPUT);
  pinMode(TRIGGER_PIN, INPUT);
  digitalWrite(RELAY1, 0);
  delay(1000);
  /*
  myRoom = (char *) malloc(sizeof(strlen(""sensor/"") + strlen(String(ESP.getChipId()).c_str())+1 ));
  strcpy(myRoom, ""sensor/"");
  strcat(myRoom, String(ESP.getChipId()).c_str());
  Serial.print(""sensor name: "");
  Serial.println(myRoom);
  */

  readConfig();
  wifiConnect();
  if (offline == 0) {
    #ifdef BLYNKLOCAL
    Blynk.config(auth, ""blynk.ogonan.com"", 80);  // in place of Blynk.begin(auth, ssid, pass);
    #endif
    #ifdef FARMLOCAL
    Blynk.config(auth, thingsboardServer, 80);
    #endif
    #ifdef BLYNK
    Blynk.config(auth);  // in place of Blynk.begin(auth, ssid, pass);
    #endif
    #if defined(BLYNKLOCAL) || defined(BLYNK) || defined(FARMLOCAL)
    boolean result = Blynk.connect(3333);  // timeout set to 10 seconds and then continue without Blynk, 3333 is 10 seconds because Blynk.connect is in 3ms units.
    Serial.print(""Blynk connect : "");
    Serial.println(result);
    if(!Blynk.connected()){
      Serial.println(""Not connected to Blynk server"");
      Blynk.connect(3333);  // try to connect to server with default timeout
    }
    else {
      Serial.println(""Connected to Blynk server"");
    }
    #endif


    #ifdef THINGSPEAK
    ThingSpeak.begin( client );
    timer.setInterval(sendinterval * 1000, sendThingSpeak);
    #endif
    #ifdef THINGSBOARD
    setup_mqtt();
    timer.setInterval(sendinterval * 1000, sendSoilMoistureData);
    #endif

    #if defined(BLYNKLOCAL) || defined(BLYNK) || defined(FARMLOCAL)
    checkConnectionTimer.setInterval(15000L, checkBlynkConnection);
    #endif

    #ifdef MULTISENSOR
      ads1015.begin();  // Initialize ads1015
      ads1015.setGain(GAIN_ONE);     // 1x gain   +/- 4.096V  1 bit = 2mV
    #endif

    #ifdef SLEEP
      ads1015.begin();  // Initialize ads1015
      ads1015.setGain(GAIN_ONE);     // 1x gain   +/- 4.096V  1 bit = 2mV
      soilMoistureSensor();
      #ifdef THINGSPEAK
      // send data to thingspeak
      sendThingSpeak();
      #endif

      #ifdef THINGSBOARD
      // send data to thingsboard
      if ( !mqttClient.connected() ) {
        reconnect();
      }
      sendSoilMoistureData();
      #endif

    Serial.println(""I'm going to sleep."");
    Serial.println(""Goodnight folks!"");

    delay(15000);
    ESP.deepSleep(sleepSeconds * 1000000);
    #endif
    upintheAir();
    timer.setInterval(1000, soilMoistureSensor);
  }
}

void loop() {
  // put your main code here, to run repeatedly:

  // wifiMulti.run();

  #ifdef THINGSBOARD
  if ( !mqttClient.connected() ) {
    reconnect();
  }

  mqttClient.loop();
  #endif
  // soilMoistureSensor();
  blink();

  #if defined(BLYNKLOCAL) || defined(BLYNK) || defined(FARMLOCAL)
  if (Blynk.connected()) {
    Blynk.run();
  }
  #endif
  checkConnectionTimer.run();
  timer.run();
}

void soilMoistureSensor()
{

  #ifdef MULTISENSOR
  soilMoistureSensor1();
  soilMoistureSensor2();
  soilMoistureSensor3();
  #else
  soilMoisture = analogRead(analogReadPin);
  Serial.print(""Analog Read A0: "");
  Serial.print(soilMoisture);
  Serial.print("", "" );

  mappedValue = map(soilMoisture, minADC, maxADC, 0, 100);


  // print mapped results to the serial monitor:
  Serial.print(""Moisture value = "" );
  Serial.println(mappedValue);

  if (mappedValue > (soilMoistureSetPoint + range)) {
    Serial.println(""High Moisture"");
    Serial.println(""Soil Moisture: Turn Relay Off"");
    digitalWrite(RELAY1, LOW);
    led1.off();
  }
  else if (mappedValue < (soilMoistureSetPoint - range)) {
    Serial.println(""Low Moisture"");
    Serial.println(""Soil Moisture: Turn Relay On"");
    digitalWrite(RELAY1, HIGH);
    led1.on();
  }
  #endif
}

void soilMoistureSensor1()
{
  soilMoisture = ads1015.readADC_SingleEnded(1);
  Serial.print(""Analog Read 1 : "");
  Serial.print(soilMoisture);
  Serial.print("", "" );

  mappedValue1 = map(soilMoisture, minADC, maxADC, 0, 100);


  // print mapped results to the serial monitor:
  Serial.print(""Moisture value 1 = "" );
  Serial.println(mappedValue1);

  if (mappedValue1 > (soilMoistureSetPoint1 + range1)) {
    Serial.println(""High Moisture"");
    Serial.println(""Soil Moisture: Turn Relay Off"");
    digitalWrite(RELAY1, LOW);
    led1.off();
  }
  else if (mappedValue1 < (soilMoistureSetPoint1 - range1)) {
    Serial.println(""Low Moisture"");
    Serial.println(""Soil Moisture: Turn Relay On"");
    digitalWrite(RELAY1, HIGH);
    led1.on();
  }
}

void soilMoistureSensor2()
{
  soilMoisture = ads1015.readADC_SingleEnded(2);
  Serial.print(""Analog Read 2 : "");
  Serial.print(soilMoisture);
  Serial.print("", "" );

  mappedValue2 = map(soilMoisture, minADC, maxADC, 0, 100);


  // print mapped results to the serial monitor:
  Serial.print(""Moisture value 2 = "" );
  Serial.println(mappedValue2);

  if (mappedValue2 > (soilMoistureSetPoint2 + range2)) {
    Serial.println(""High Moisture"");
    Serial.println(""Soil Moisture: Turn Relay Off"");
    digitalWrite(RELAY2, LOW);
    led2.off();
  }
  else if (mappedValue2 < (soilMoistureSetPoint2 - range2)) {
    Serial.println(""Low Moisture"");
    Serial.println(""Soil Moisture: Turn Relay On"");
    digitalWrite(RELAY2, HIGH);
    led2.on();
  }
}

void soilMoistureSensor3()
{
  soilMoisture = ads1015.readADC_SingleEnded(3);
  Serial.print(""Analog Read 3 : "");
  Serial.print(soilMoisture);
  Serial.print("", "" );

  mappedValue3 = map(soilMoisture, minADC, maxADC, 0, 100);


  // print mapped results to the serial monitor:
  Serial.print(""Moisture value 3 = "" );
  Serial.println(mappedValue3);

  if (mappedValue3 > (soilMoistureSetPoint3 + range3)) {
    Serial.println(""High Moisture"");
    Serial.println(""Soil Moisture: Turn Relay Off"");
    digitalWrite(RELAY3, LOW);
    led3.off();
  }
  else if (mappedValue3 < (soilMoistureSetPoint3 - range3)) {
    Serial.println(""Low Moisture"");
    Serial.println(""Soil Moisture: Turn Relay On"");
    digitalWrite(RELAY3, HIGH);
    led3.on();
  }
}


void sendSoilMoistureData()
{


  // Just debug messages
  Serial.println(""Send soil moisture data."");
  Serial.print( ""[ "") ;
  Serial.print( mappedValue );
  Serial.print( ""]   -> "" );

  sendDatatoThingsboard(""\\""soilMoisture1\\"":"", mappedValue1, ""\\""active1\\"":"", digitalRead(RELAY1));
  delay(1000);
  sendDatatoThingsboard(""\\""soilMoisture2\\"":"", mappedValue2, ""\\""active2\\"":"", digitalRead(RELAY2));
  delay(1000);
  sendDatatoThingsboard(""\\""soilMoisture3\\"":"", mappedValue3, ""\\""active3\\"":"", digitalRead(RELAY3));

}

void sendDatatoThingsboard(String field1, int value, String field2, int active)
{

  // Prepare a JSON payload string
  String payload = ""{"";
  payload += field1;  payload += value; payload += "","";

  #ifdef SLEEP
  float volt = checkBattery();
  payload += ""\\""battery\\"":""; payload += volt; payload += "","";
  #endif
  payload += field2; payload += active ? true : false;
  payload += ""}"";

  // Send payload
  char attributes[128];
  payload.toCharArray( attributes, 128 );
  mqttClient.publish( ""v1/devices/me/telemetry"", attributes );
  Serial.println( attributes );
}

void blink()
{
  unsigned long currentMillis = millis();

  // if enough millis have elapsed
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;

    // toggle the LED
    ledState = !ledState;
    digitalWrite(BUILTIN_LED, ledState);
  }
}

void wifiConnect()
{
  int retry2Connect = 0;
  String SSID = WiFi.SSID();
  String PSK = WiFi.psk();

  WiFi.mode(WIFI_STA);
  Serial.println();
  Serial.println(WiFi.SSID());
  Serial.println(WiFi.psk());

  WiFi.begin();
  Serial.print(""Connecting"");
  Serial.println();

  // wifiMulti.addAP(""Red1"", ""12345678"");
  // wifiMulti.addAP(""ogofarm"", ""ogofarm2018"");
  // wifiMulti.addAP(""Red_Plus"", ""12345678"");
  // wifiMulti.addAP(""Red"", ""12345678"");

  Serial.println(""Connecting Wifi..."");

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(""1"");
    if ( digitalRead(TRIGGER_PIN) == LOW ) {
      ondemandWiFi();
    }
    retry2Connect++;
    if (retry2Connect >= 30) {
      ondemandWiFi();
      break;
    }
  }

  Serial.println();
  if (offline == 0) {
    Serial.print(""Connected, IP address: "");
    Serial.println(WiFi.localIP());
  }

  Serial.println();
}

void ondemandWiFi()
{
  WiFiManager wifiManager;

  wifiManager.setBreakAfterConfig(true);
  wifiManager.setConfigPortalTimeout(60);

  WiFiManagerParameter custom_mqtt_server(""server"", ""mqtt server"", c_thingsboardServer, 40);
  WiFiManagerParameter custom_mqtt_port(""port"", ""mqtt port"", c_mqttport, 7);
  WiFiManagerParameter custom_sendinterval(""interval"", ""send data interval time (second)"", c_sendinterval, 7);
  WiFiManagerParameter custom_c_auth(""c_auth"", ""Auth Token"", c_auth, 37);
  WiFiManagerParameter custom_thingsboard_token(""token"", ""thingsboard token"", c_token, 32);
  WiFiManagerParameter custom_c_writeapikey(""c_writeapikey"", ""Write API Key : ThingSpeak"", c_writeAPIKey, 17);
  #ifdef SLEEP
  WiFiManagerParameter custom_c_sleepSeconds(""c_sleepSeconds"", ""Sleep Interval (second)"", c_sleepSeconds, 7);
  #endif

  wifiManager.setSaveConfigCallback(saveConfigCallback);
  wifiManager.addParameter(&custom_mqtt_server);
  wifiManager.addParameter(&custom_mqtt_port);
  wifiManager.addParameter(&custom_sendinterval);
  wifiManager.addParameter(&custom_c_auth);
  wifiManager.addParameter(&custom_thingsboard_token);
  wifiManager.addParameter(&custom_c_writeapikey);
  #ifdef SLEEP
  wifiManager.addParameter(&custom_c_sleepSeconds);
  #endif

  delay(10);

  if (!wifiManager.startConfigPortal(""ogoSwitch-SoilWatch"")) {
      Serial.println(""failed to connect and hit timeout"");
      delay(3000);
      //reset and try again, or maybe put it to deep sleep
      ESP.reset();
      delay(5000);
    }
  //if you get here you have connected to the WiFi
  Serial.println(""connected...yeey :)"");

  if (shouldSaveConfig) {
    Serial.println(""Saving config..."");
    strcpy(c_thingsboardServer, custom_mqtt_server.getValue());
    strcpy(c_mqttport, custom_mqtt_port.getValue());
    strcpy(c_token, custom_thingsboard_token.getValue());
    strcpy(c_sendinterval, custom_sendinterval.getValue());
    strcpy(c_auth, custom_c_auth.getValue());
    strcpy(c_writeAPIKey, custom_c_writeapikey.getValue());
    #ifdef SLEEP
    strcpy(c_sleepSeconds, custom_c_sleepSeconds.getValue());
    #endif

    strcpy(thingsboardServer, c_thingsboardServer);
    mqttport = atoi(c_mqttport);
    strcpy(token, c_token);
    sendinterval = atoi(c_sendinterval);
    strcpy(auth, c_auth);
    strcpy(writeAPIKey, c_writeAPIKey);
    #ifdef SLEEP
    sleepSeconds = atoi(c_sleepSeconds);
    #endif

    Serial.print(""thingsboard server: "");
    Serial.println(c_thingsboardServer);
    Serial.print(""mqtt port: "");
    Serial.println(c_mqttport);
    Serial.print(""ThingsBoard device token: "");
    Serial.println(c_token);
    Serial.print(""send interval: "");
    Serial.println(c_sendinterval);
    Serial.print(""Blynk auth token : "");
    Serial.println(auth);
    Serial.print(""Thinspeak write API Key : "");
    Serial.println(writeAPIKey);
    #ifdef SLEEP
    Serial.println(""Sleep interval : "");
    Serial.print(c_sleepSeconds);
    #endif

    writeEEPROM(thingsboardServer, 0, 40);
    writeEEPROM(c_mqttport, 40, 7);
    eeWriteInt(47, sendinterval);
    writeEEPROM(auth, 60, 32);
    writeEEPROM(token, 92, 20);
    writeEEPROM(writeAPIKey, 112, 16);
    #ifdef SLEEP
    eeWriteInt(144, sleepSeconds);
    #endif
    eeWriteInt(500, 6550);
  }
}

//callback notifying us of the need to save config
void saveConfigCallback () {
  Serial.println(""Should save config"");
  shouldSaveConfig = true;
}

void readConfig()
{
  EEPROM.begin(512);

  memset(thingsboardServer, 0, sizeof(thingsboardServer));
  memset(c_mqttport, 0, sizeof(c_mqttport));
  memset(auth, 0, sizeof(auth));
  memset(token, 0, sizeof(token));
  memset(writeAPIKey, 0, sizeof(writeAPIKey));
  #ifdef SLEEP
  memset(c_sleepSeconds, 0, sizeof(c_sleepSeconds));
  #endif

  readEEPROM(thingsboardServer, 0, 40);
  readEEPROM(c_mqttport, 40, 7);
  sendinterval = eeGetInt(47);
  readEEPROM(auth, 60, 32);         // blynk auth token
  readEEPROM(token, 92, 20);        // thingsboard device token
  readEEPROM(writeAPIKey, 112, 32); // thingspeak write api key
  mqttport = atoi(c_mqttport);
  #ifdef SLEEP
  sleepSeconds = eeGetInt(144);
  #endif

  Serial.println();
  Serial.print(""thingsboard server: "");
  Serial.println(thingsboardServer);
  Serial.print(""mqtt port: "");
  Serial.println(mqttport);
  Serial.print(""send interval: "");
  Serial.println(sendinterval);
  Serial.print(""blynk auth token: "");
  Serial.println(auth);
  Serial.print(""device token: "");
  Serial.println(token);
  #ifdef SLEEP
  Serial.print(""sleep interval: "");
  Serial.print(sleepSeconds);
  #endif


  int saved = eeGetInt(500);
  if (saved == 6550) {
    strcpy(c_thingsboardServer, thingsboardServer);
    itoa(mqttport, c_mqttport, 10);
    strcpy(c_auth, auth);
    strcpy(c_token, token);
    strcpy(c_writeAPIKey, writeAPIKey);
    itoa(sendinterval, c_sendinterval, 10);
    #ifdef SLEEP
    itoa(sleepSeconds, c_sleepSeconds, 10);
    #endif
  }
}

void readEEPROM(char* buff, int offset, int len) {
    int i;
    for (i=0;i<len;i++) {
        buff[i] = (char)EEPROM.read(offset+i);
    }
    buff[len] = '\\0';
}

void writeEEPROM(char* buff, int offset, int len) {
    int i;
    for (i=0;i<len;i++) {
        EEPROM.write(offset+i,buff[i]);
    }
    EEPROM.commit();
}

void eeWriteInt(int pos, int val) {
    byte* p = (byte*) &val;
    EEPROM.write(pos, *p);
    EEPROM.write(pos + 1, *(p + 1));
    EEPROM.write(pos + 2, *(p + 2));
    EEPROM.write(pos + 3, *(p + 3));
    EEPROM.commit();
}

int eeGetInt(int pos) {
  int val;
  byte* p = (byte*) &val;
  *p        = EEPROM.read(pos);
  *(p + 1)  = EEPROM.read(pos + 1);
  *(p + 2)  = EEPROM.read(pos + 2);
  *(p + 3)  = EEPROM.read(pos + 3);
  return val;
}

int blynkreconnect = 0;
void checkBlynkConnection()
{
  int mytimeout;
  bool blynkConnectedResult = false;



  Serial.println(""Check Blynk connection."");
  blynkConnectedResult = Blynk.connected();
  if (!blynkConnectedResult) {
    Serial.println(""Blynk not connected"");
    mytimeout = millis() / 1000;
    Serial.println(""Blynk trying to reconnect."");
    while (!blynkConnectedResult) {
      blynkConnectedResult = Blynk.connect(3333);
      Serial.print(""."");
      if((millis() / 1000) > mytimeout + 3) { // try for less than 4 seconds
        Serial.println(""Blynk reconnect timeout."");
        break;
      }
    }
  }
  if (blynkConnectedResult) {
      Serial.println(""Blynk connected"");
  }
  else {
    Serial.println(""Blynk not connected"");
    Serial.print(""blynkreconnect: "");
    Serial.println(blynkreconnect);
    blynkreconnect++;
    if (blynkreconnect >= 10) {
      blynkreconnect = 0;
      // delay(60000);
      // ESP.reset();
    }
  }
}

#ifdef THINGSPEAK
void sendThingSpeak()
{
  ThingSpeak.setField( 1, mappedValue );
  ThingSpeak.setField( 2, digitalRead(RELAY1));
  #ifdef SLEEP
      float volt = checkBattery();
      ThingSpeak.setField(3, volt);
    #endif
  int writeSuccess = ThingSpeak.writeFields( channelID, writeAPIKey );
  Serial.print(""Return Code: "");
  Serial.println(writeSuccess);
  Serial.println();
}
#endif

float checkBattery()
{
  float volt = 0.0;

  #ifndef SLEEP
  unsigned int raw = 0;
  raw = analogRead(A0);
  volt = raw * (3.7 / 1023.0);
  // volt = volt * 4.2;
  Serial.print(""Analog read: "");
  Serial.println(raw);
  #endif

  #ifdef SLEEP
  int16_t adc0;

  adc0 = ads1015.readADC_SingleEnded(0);

  volt = ((float) adc0 * 3.0) / 1000.0;
  Serial.print(""Analog read A1: "");
  Serial.println(adc0);
  #endif



  // String v = String(volt);
  Serial.print(""Battery voltage: "");
  Serial.println(volt);

  return(volt);
}

void setup_mqtt()
{
  #ifdef THINGSBOARD
  Serial.println(""FARM Server : ""+String(thingsboardServer)+"" mqtt port: ""+String(mqttport));
  mqttClient.setServer(thingsboardServer, mqttport);  // default port 1883, mqtt_server, thingsboardServer
  #else
  mqttClient.setServer(mqtt_server, mqttport);
  #endif
  mqttClient.setCallback(callback);
  if (mqttClient.connect(myRoom, token, NULL)) {
    Serial.print(""mqtt connected : "");
    Serial.println(thingsboardServer);  // mqtt_server
    Serial.println();
  }
}


void callback(char* topic, byte* payload, unsigned int length) {
  int i;

  Serial.print(""Message arrived ["");
  Serial.print(topic);
  Serial.print(""] "");
  for (i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();

  char json[length + 1];
  strncpy (json, (char*)payload, length);
  json[length] = '\\0';

  // Decode JSON request
  StaticJsonBuffer<200> jsonBuffer;
  JsonObject& data = jsonBuffer.parseObject((char*)json);

  if (!data.success())
  {
    Serial.println(""parseObject() failed"");
    return;
  }

  // Check request method
  String methodName = String((const char*)data[""method""]);

  if (methodName.equals(""getGpioStatus"")) {
    // Reply with GPIO status
    String responseTopic = String(topic);
    responseTopic.replace(""request"", ""response"");
    mqttClient.publish(responseTopic.c_str(), get_gpio_status().c_str());
  } else if (methodName.equals(""setGpioStatus"")) {
    // Update GPIO status and reply
    set_gpio_status(data[""params""][""pin""], data[""params""][""enabled""]);
    String responseTopic = String(topic);
    responseTopic.replace(""request"", ""response"");
    mqttClient.publish(responseTopic.c_str(), get_gpio_status().c_str());
    mqttClient.publish(""v1/devices/me/attributes"", get_gpio_status().c_str());
  }

}


String get_gpio_status() {
  // Prepare gpios JSON payload string
  StaticJsonBuffer<200> jsonBuffer;
  JsonObject& data = jsonBuffer.createObject();

  data[String(GPIO0_PIN)] = gpioState[0] ? true : false;
  data[String(GPIO2_PIN)] = gpioState[1] ? true : false;

  char payload[256];
  data.printTo(payload, sizeof(payload));

  String strPayload = String(payload);
  Serial.print(""Get gpio status: "");
  Serial.println(strPayload);

  return strPayload;
}

void set_gpio_status(int pin, boolean enabled) {
  if (pin == GPIO0_PIN) {
    // Output GPIOs state
    digitalWrite(GPIO0, enabled ? HIGH : LOW);
    // Update GPIOs state
    gpioState[0] = enabled;
  }
  else if (pin == GPIO2_PIN) {
    // Output GPIOs state
    digitalWrite(GPIO2, enabled ? HIGH : LOW);
    // Update GPIOs state
    gpioState[1] = enabled;
  }

}

bool reconnect()
{

  unsigned long now = millis();

  if (1000 > now - lastMqttConnectionAttempt) {
    // Do not repeat within 1 sec.
    return false;
  }
  Serial.println(""Connecting to MQTT server..."");

  if (!mqttClient.connected()) {
    if (WiFi.status() != WL_CONNECTED) {
      wifiConnect();
    }
    Serial.print(""Attempting MQTT connection..."");
    // Attempt to connect
    #ifdef THINGSBOARD
    if (mqttClient.connect(myRoom, token, NULL)) {  // connect to thingsboards
    #else
    if (mqttClient.connect(myRoom, mqtt_user, mqtt_password)) {  // connect to thingsboards
    #endif
      Serial.println(""Connected!"");
      // Once connected, publish an announcement...
      // mqttClient.publish(roomStatus, ""hello world"");
    }
    else {
      lastMqttConnectionAttempt = now;
      return false;
    }

  }

  return true;
}

void upintheAir()
{
  String fwURL = String( firmwareUrlBase );
  fwURL.concat( firmware_name );
  String fwVersionURL = fwURL;
  fwVersionURL.concat( "".version"" );

  Serial.println( ""Checking for firmware updates."" );
  // Serial.print( ""MAC address: "" );
  // Serial.println( mac );
  Serial.print( ""Firmware version URL: "" );
  Serial.println( fwVersionURL );

  HTTPClient httpClient;
  httpClient.begin( fwVersionURL );
  int httpCode = httpClient.GET();
  if( httpCode == 200 ) {
    String newFWVersion = httpClient.getString();

    Serial.print( ""Current firmware version: "" );
    Serial.println( FW_VERSION );
    Serial.print( ""Available firmware version: "" );
    Serial.println( newFWVersion );

    int newVersion = newFWVersion.toInt();

    if( newVersion > FW_VERSION ) {
      Serial.println( ""Preparing to update"" );

      String fwImageURL = fwURL;
      fwImageURL.concat( "".bin"" );
      t_httpUpdate_return ret = ESPhttpUpdate.update( fwImageURL );

      switch(ret) {
        case HTTP_UPDATE_FAILED:
          Serial.printf(""HTTP_UPDATE_FAILD Error (%d): %s"", ESPhttpUpdate.getLastError(), ESPhttpUpdate.getLastErrorString().c_str());
          break;

        case HTTP_UPDATE_NO_UPDATES:
          Serial.println(""HTTP_UPDATE_NO_UPDATES"");
          break;
      }
    }
    else {
      Serial.println( ""Already on latest version"" );
    }
  }
  else {
    Serial.print( ""Firmware version check failed, got HTTP response code "" );
    Serial.println( httpCode );
  }
  httpClient.end();
  // ESPhttpUpdate.update(""www.ogonan.com"", 80, ""/ogoupdate/ogoswitch_blynk.ino.d1_mini.bin"");
}

BLYNK_CONNECTED()
{
  Blynk.syncVirtual(V1);
  Blynk.syncVirtual(V2);
  Blynk.syncVirtual(V3);
  Blynk.syncVirtual(V4);
  Blynk.syncVirtual(V5);
  Blynk.syncVirtual(V6);

}

BLYNK_WRITE(V1)
{
  soilMoistureSetPoint1 = param.asInt();
  Serial.print(""Set point: "");
  Serial.println(soilMoistureSetPoint1);
  Serial.println();

  Blynk.virtualWrite(V31, soilMoistureSetPoint1+range1);
  Blynk.virtualWrite(V32, soilMoistureSetPoint1-range1);
}

BLYNK_WRITE(V2)
{
  range1 = param.asInt();
  Serial.print(""Range: "");
  Serial.println(range1);
  Serial.println();

  Blynk.virtualWrite(V31, soilMoistureSetPoint1+range1);
  Blynk.virtualWrite(V32, soilMoistureSetPoint1-range1);
}

BLYNK_WRITE(V3)
{
  soilMoistureSetPoint2 = param.asInt();
  Serial.print(""Set point: "");
  Serial.println(soilMoistureSetPoint2);
  Serial.println();

  Blynk.virtualWrite(V33, soilMoistureSetPoint2+range2);
  Blynk.virtualWrite(V34, soilMoistureSetPoint2-range2);
}

BLYNK_WRITE(V4)
{
  range2 = param.asInt();
  Serial.print(""Range: "");
  Serial.println(range2);
  Serial.println();

  Blynk.virtualWrite(V33, soilMoistureSetPoint2+range2);
  Blynk.virtualWrite(V34, soilMoistureSetPoint2-range2);
}

BLYNK_WRITE(V5)
{
  soilMoistureSetPoint3 = param.asInt();
  Serial.print(""Set point: "");
  Serial.println(soilMoistureSetPoint3);
  Serial.println();

  Blynk.virtualWrite(V35, soilMoistureSetPoint3+range3);
  Blynk.virtualWrite(V36, soilMoistureSetPoint3-range3);
}

BLYNK_WRITE(V6)
{
  range3 = param.asInt();
  Serial.print(""Range: "");
  Serial.println(range3);
  Serial.println();

  Blynk.virtualWrite(V35, soilMoistureSetPoint3+range3);
  Blynk.virtualWrite(V36, soilMoistureSetPoint3-range3);
}


BLYNK_READ(V10)
{
  Blynk.virtualWrite(V10, mappedValue1);
}

BLYNK_READ(V11)
{
  Blynk.virtualWrite(V11, mappedValue2);
}

BLYNK_READ(V12)
{
  Blynk.virtualWrite(V12, mappedValue3);
}
",8303,False,1348.2354450607206,median
"*&---------------------------------------------------------------------*
*& Report  ZBASIC_REPORT_ALVGRID2
*&
*&---------------------------------------------------------------------*
*&
*&
*&---------------------------------------------------------------------*
REPORT zdemogit_rept_alvgrid3.

""Define Selection screen
PARAMETERS: p_test TYPE xfeld.

""define the global table display
TYPES: BEGIN OF ty_output,
*       <here your fields...>
         field TYPE c,
       END OF ty_output,
       ty_output_tt TYPE STANDARD TABLE OF ty_output.
"" Table global
DATA t_output TYPE ty_output_tt.
""e.g
DATA: lt_output TYPE STANDARD TABLE OF vbap.


""Ok code for screen 9000
DATA g_okcode TYPE sy-ucomm.

CLASS lcl_alv_grid DEFINITION DEFERRED.

CLASS lcl_report DEFINITION ABSTRACT FINAL CREATE PRIVATE.
  PUBLIC SECTION.
    INTERFACES: zif_git_report.
ENDCLASS.

CLASS lcl_alv_grid DEFINITION INHERITING FROM zcl_git_alvgrid_template.
  PUBLIC SECTION.
    ALIASES: m_alv_grid FOR zif_git_report_alvgrid~m_alv_grid.

    METHODS constructor IMPORTING i_container_name TYPE char40 DEFAULT 'MY_CONTAINER' i_scree_alv TYPE sy-dynnr DEFAULT '9000'.
*    METHODS: zif_report_alvgrid~on_after_refresh REDEFINITION,
*             zif_report_alvgrid~on_after_user_command REDEFINITION,
*             zif_report_alvgrid~on_before_user_command REDEFINITION,
*             zif_report_alvgrid~on_button_click REDEFINITION,
*             zif_report_alvgrid~on_context_menu_request REDEFINITION,
*             zif_report_alvgrid~on_data_changed REDEFINITION,
*             zif_report_alvgrid~on_data_changed_finished REDEFINITION,
*             zif_report_alvgrid~on_delayed_callback REDEFINITION,
*             zif_report_alvgrid~on_double_click REDEFINITION,
*             zif_report_alvgrid~on_drop_external_files REDEFINITION,
*             zif_report_alvgrid~on_end_of_list REDEFINITION,
*             zif_report_alvgrid~on_hotspot_click REDEFINITION,
*             zif_report_alvgrid~on_left_click_design REDEFINITION,
*             zif_report_alvgrid~on_left_click_run REDEFINITION,
*             zif_report_alvgrid~on_menu_button REDEFINITION,
*             zif_report_alvgrid~on_move_control REDEFINITION,
*             zif_report_alvgrid~on_ondrag REDEFINITION,
*             zif_report_alvgrid~on_ondrop REDEFINITION,
*             zif_report_alvgrid~on_ondropcomplete REDEFINITION,
*             zif_report_alvgrid~on_ondropgetflavor REDEFINITION,
*             zif_report_alvgrid~on_onf1 REDEFINITION,
*             zif_report_alvgrid~on_onf4 REDEFINITION,
*             zif_report_alvgrid~on_print_end_of_list REDEFINITION,
*             zif_report_alvgrid~on_print_end_of_page REDEFINITION,
*             zif_report_alvgrid~on_print_top_of_list REDEFINITION,
*             zif_report_alvgrid~on_print_top_of_page REDEFINITION,
*             zif_report_alvgrid~on_right_click REDEFINITION,
*             zif_report_alvgrid~on_size_control REDEFINITION,
*             zif_report_alvgrid~on_subtotal_text REDEFINITION,
*             zif_report_alvgrid~on_toolbar REDEFINITION,
*             zif_report_alvgrid~on_top_of_page REDEFINITION,
*             zif_report_alvgrid~on_user_command REDEFINITION,
*             zif_report_alvgrid~get_data_to_display REDEFINITION,
*             zif_report_alvgrid~get_fieldcatalog REDEFINITION.
    METHODS: zif_git_report_alvgrid~get_fieldcatalog REDEFINITION,
      zif_git_report_alvgrid~on_user_command REDEFINITION,
      zif_git_report_alvgrid~on_after_refresh REDEFINITION,
      zif_git_report_alvgrid~on_after_user_command REDEFINITION,
      zif_git_report_alvgrid~on_before_user_command REDEFINITION,
      zif_git_report_alvgrid~on_button_click REDEFINITION,
      zif_git_report_alvgrid~on_context_menu_request REDEFINITION,
      zif_git_report_alvgrid~on_data_changed REDEFINITION,
      zif_git_report_alvgrid~on_data_changed_finished REDEFINITION,
      zif_git_report_alvgrid~on_delayed_callback REDEFINITION,
      zif_git_report_alvgrid~on_double_click REDEFINITION,
      zif_git_report_alvgrid~on_drop_external_files REDEFINITION,
      zif_git_report_alvgrid~on_end_of_list REDEFINITION,
      zif_git_report_alvgrid~on_hotspot_click REDEFINITION,
      zif_git_report_alvgrid~on_left_click_design REDEFINITION,
      zif_git_report_alvgrid~on_left_click_run REDEFINITION,
      zif_git_report_alvgrid~on_menu_button REDEFINITION,
      zif_git_report_alvgrid~on_move_control REDEFINITION,
      zif_git_report_alvgrid~on_ondrag REDEFINITION,
      zif_git_report_alvgrid~on_ondrop REDEFINITION,
      zif_git_report_alvgrid~on_ondropcomplete REDEFINITION,
      zif_git_report_alvgrid~on_ondropgetflavor REDEFINITION,
      zif_git_report_alvgrid~on_onf1 REDEFINITION,
      zif_git_report_alvgrid~on_onf4 REDEFINITION,
      zif_git_report_alvgrid~on_print_end_of_list REDEFINITION,
      zif_git_report_alvgrid~on_print_end_of_page REDEFINITION,
      zif_git_report_alvgrid~on_print_top_of_list REDEFINITION,
      zif_git_report_alvgrid~on_print_top_of_page REDEFINITION,
      zif_git_report_alvgrid~on_right_click REDEFINITION,
      zif_git_report_alvgrid~on_size_control REDEFINITION,
      zif_git_report_alvgrid~on_subtotal_text REDEFINITION,
      zif_git_report_alvgrid~on_toolbar REDEFINITION,
      zif_git_report_alvgrid~on_top_of_page REDEFINITION,
      zif_git_report_alvgrid~get_data_to_display REDEFINITION.

ENDCLASS.

CLASS lcl_report IMPLEMENTATION.

  METHOD zif_git_report~initialization.
  ENDMETHOD.
  METHOD zif_git_report~start_of_selection.
  ENDMETHOD.
  METHOD zif_git_report~end_of_selection.
  ENDMETHOD.
  METHOD zif_git_report~load_of_program.
  ENDMETHOD.
  METHOD zif_git_report~at_selection_screen_output.
  ENDMETHOD.
  METHOD zif_git_report~at_selection_screen.
  ENDMETHOD.
  METHOD zif_git_report~at_selection_screen_on.
  ENDMETHOD.
  METHOD zif_git_report~at_selection_screen_on_end_of.
  ENDMETHOD.
  METHOD zif_git_report~atsel_scrn_on_help_request_for.
  ENDMETHOD.
  METHOD zif_git_report~atsel_scr_on_value_request_for.
  ENDMETHOD.
  METHOD zif_git_report~at_selection_screen_on_block.
  ENDMETHOD.
  METHOD zif_git_report~atsel_scr_on_radiobutton_group.
  ENDMETHOD.
ENDCLASS.



CLASS lcl_alv_grid IMPLEMENTATION.
  METHOD zif_git_report_alvgrid~on_user_command.
    BREAK-POINT.
    WRITE /: 'User Command', e_ucomm.
  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_after_refresh.

  ENDMETHOD.
  METHOD zif_git_report_alvgrid~on_after_user_command.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_before_user_command.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_button_click.
    BREAK-POINT.
  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_context_menu_request.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_data_changed.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_data_changed_finished.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_delayed_callback.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_double_click.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_drop_external_files.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_end_of_list.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_hotspot_click.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_left_click_design.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_left_click_run.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_menu_button.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_move_control.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_ondrag.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_ondrop.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_ondropcomplete.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_ondropgetflavor.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_onf1.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_onf4.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_print_end_of_list.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_print_end_of_page.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_print_top_of_list.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_print_top_of_page.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_right_click.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_size_control.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_subtotal_text.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_toolbar.
    DATA: ls_toolbar TYPE stb_button.
*... Normal Button
    CLEAR      ls_toolbar.
    ls_toolbar-function  = 'EnableStaticMenu'.
    ls_toolbar-icon      = space.
    ls_toolbar-butn_type = '0'.
    ls_toolbar-disabled  = space.
    ls_toolbar-text      = 'EnableStaticMenu'.
    ls_toolbar-quickinfo = space.
    ls_toolbar-checked   = space.
    APPEND ls_toolbar TO e_object->mt_toolbar.
  ENDMETHOD.

  METHOD zif_git_report_alvgrid~on_top_of_page.

  ENDMETHOD.

  METHOD zif_git_report_alvgrid~get_data_to_display.

*    SELECT vbeln, posnr
*    FROM vbap
*    INTO CORRESPONDING FIELDS OF TABLE @ct_table_data
*      ""lt_output
*    "" @DATA(lt_data)
*    UP TO 100 ROWS.
*    "" get reference table
*    GET REFERENCE OF ct_table_data INTO zif_git_report_alvgrid~m_output_table.

  ENDMETHOD.

  METHOD constructor.
    super->constructor(
      i_container_name = 'MY_CONTAINER'
      i_scree_alv      = '9000' ).

    ""EVENTS to register!
    ""to Handel ALV event register
    SET HANDLER me->zif_git_report_alvgrid~on_user_command
                FOR m_alv_grid.
    SET HANDLER me->zif_git_report_alvgrid~on_before_user_command
                FOR   m_alv_grid.
    SET HANDLER me->zif_git_report_alvgrid~on_after_user_command
                FOR m_alv_grid.
    ""toolbar menu
    SET HANDLER me->zif_git_report_alvgrid~on_toolbar
                FOR m_alv_grid.
    SET HANDLER me->zif_git_report_alvgrid~on_double_click
                FOR m_alv_grid.
    SET HANDLER me->zif_git_report_alvgrid~on_hotspot_click
                FOR m_alv_grid.
    SET HANDLER me->zif_git_report_alvgrid~on_button_click
                FOR m_alv_grid.
    SET HANDLER me->zif_git_report_alvgrid~on_onf1
                FOR m_alv_grid.
    SET HANDLER me->zif_git_report_alvgrid~on_onf4
                FOR m_alv_grid.
    SET HANDLER me->zif_git_report_alvgrid~on_menu_button
                FOR m_alv_grid.
    SET HANDLER me->zif_git_report_alvgrid~on_data_changed
                FOR m_alv_grid.
    SET HANDLER me->zif_git_report_alvgrid~on_data_changed_finished
               FOR m_alv_grid.
  ENDMETHOD.

  METHOD zif_git_report_alvgrid~get_fieldcatalog.

*    DATA:
*      l_columns      TYPE REF TO cl_salv_columns_table,
*      l_aggregations TYPE REF TO cl_salv_aggregations.
*      l_salv_table   TYPE REF TO cl_salv_table.
    FIELD-SYMBOLS:
      <l_table>         TYPE STANDARD TABLE.

    ASSIGN zif_git_report_alvgrid~m_output_table->* TO <l_table> .
*...New ALV Instance ...............................................
    TRY.
        cl_salv_table=>factory(
          EXPORTING
            list_display = abap_false
          IMPORTING
            r_salv_table = DATA(l_salv_table)
          CHANGING
            t_table      = <l_table> ).
      CATCH cx_salv_msg.                                ""#EC NO_HANDLER
    ENDTRY.
*    DATA(l_columns)  = l_salv_table->get_columns( ).
*    DATA(l_aggregations) = l_salv_table->get_aggregations( ).
    et_catalog =
      cl_salv_controller_metadata=>get_lvc_fieldcatalog(
        r_columns             = l_salv_table->get_columns( )
        r_aggregations        = l_salv_table->get_aggregations( ) ).

*Catalogo tipo DDIC LVC_T_FCAT
*Para convertior a tipo SLIS LVC_TRANSFER_TO_SLIS
  ENDMETHOD.

ENDCLASS.

INITIALIZATION.
  lcl_report=>zif_git_report~initialization( ).

AT SELECTION-SCREEN OUTPUT.
  lcl_report=>zif_git_report~at_selection_screen_output( ).

AT SELECTION-SCREEN.
  lcl_report=>zif_git_report~at_selection_screen( ).

LOAD-OF-PROGRAM.
  lcl_report=>zif_git_report~load_of_program( ).

*END-OF-SELECTION. Obsolete
*  lcl_report=>zif_git_report~end_of_selection( ).

AT SELECTION-SCREEN ON p_test.
  lcl_report=>zif_git_report~at_selection_screen_on( ).

*AT SELECTION-SCREEN ON END OF p_test.
*   lcl_report=>zif_git_report~at_selection_screen_on_end_of( ).

AT SELECTION-SCREEN ON HELP-REQUEST FOR p_test.
  lcl_report=>zif_git_report~atsel_scrn_on_help_request_for( ).

AT SELECTION-SCREEN ON VALUE-REQUEST FOR  p_test.
  lcl_report=>zif_git_report~atsel_scr_on_value_request_for( ).

*  AT SELECTION-SCREEN ON BLOCK
*   lcl_report=>zif_git_report~at_selection_screen_on_block( ).
*    AT SELECTION-SCREEN on RADIOBUTTON GROUP
*   lcl_report=>zif_git_report~atsel_scr_on_radiobutton_group( ).

START-OF-SELECTION.
  lcl_report=>zif_git_report~start_of_selection( ).

  DATA(lr_alvgrid) = NEW lcl_alv_grid(
*      i_container_name = 'MY_CONTAINER'
*      i_scree_alv      = '9000'
  ).




*  ""EVENTS to register! done in constructor
*  ""to Handel ALV event register
*  SET HANDLER lr_alvgrid->zif_git_report_alvgrid~on_user_command
*              FOR lr_alvgrid->zif_git_report_alvgrid~m_alv_grid.
*  SET HANDLER lr_alvgrid->zif_git_report_alvgrid~on_before_user_command
*              FOR lr_alvgrid->zif_git_report_alvgrid~m_alv_grid.
*  SET HANDLER lr_alvgrid->zif_git_report_alvgrid~on_after_user_command
*              FOR lr_alvgrid->zif_git_report_alvgrid~m_alv_grid.
*  ""toolbar menu
*  SET HANDLER lr_alvgrid->zif_git_report_alvgrid~on_toolbar
*              FOR lr_alvgrid->zif_git_report_alvgrid~m_alv_grid.
*
*  SET HANDLER lr_alvgrid->zif_git_report_alvgrid~on_double_click
*              FOR lr_alvgrid->zif_git_report_alvgrid~m_alv_grid.
*  SET HANDLER lr_alvgrid->zif_git_report_alvgrid~on_hotspot_click
*              FOR lr_alvgrid->zif_git_report_alvgrid~m_alv_grid.
*  SET HANDLER lr_alvgrid->zif_git_report_alvgrid~on_button_click
*              FOR lr_alvgrid->zif_git_report_alvgrid~m_alv_grid.
*  SET HANDLER lr_alvgrid->zif_git_report_alvgrid~on_onf1
*              FOR lr_alvgrid->zif_git_report_alvgrid~m_alv_grid.
*  SET HANDLER lr_alvgrid->zif_git_report_alvgrid~on_onf4
*              FOR lr_alvgrid->zif_git_report_alvgrid~m_alv_grid.
*  SET HANDLER lr_alvgrid->zif_git_report_alvgrid~on_menu_button
*              FOR lr_alvgrid->zif_git_report_alvgrid~m_alv_grid.
*  SET HANDLER lr_alvgrid->zif_git_report_alvgrid~on_data_changed
*              FOR lr_alvgrid->zif_git_report_alvgrid~m_alv_grid.
*  SET HANDLER lr_alvgrid->zif_git_report_alvgrid~on_data_changed_finished
*             FOR lr_alvgrid->zif_git_report_alvgrid~m_alv_grid.

  ""the table shall be defined global in report so a correct referece to the table can be created
  lr_alvgrid->zif_git_report_alvgrid~get_data_to_display(
    CHANGING
      ct_table_data = lt_output ).
  "" get field catalog (the table should be filled first)
  lr_alvgrid->zif_git_report_alvgrid~get_fieldcatalog(
     IMPORTING
       et_catalog = DATA(lt_fieldcatalog)
   ).

  FIELD-SYMBOLS : <table> TYPE ANY TABLE.
  ASSIGN lr_alvgrid->zif_git_report_alvgrid~m_output_table->* TO <table> .

  lr_alvgrid->zif_git_report_alvgrid~m_alv_grid->set_table_for_first_display(
*    EXPORTING
*      i_buffer_active               =     "" Buffering Active
*      i_bypassing_buffer            =     "" Switch Off Buffer
*      i_consistency_check           =     "" Starting Consistency Check for Interface Error Recognition
*      i_structure_name              =  'VBAP'   "" Internal Output Table Structure Name
*      is_variant                    =     "" Layout
*      i_save                        =     "" Save Layout
*      i_default                     = 'X'    "" Default Display Variant
*      is_layout                     =     "" Layout
*      is_print                      =     "" Print Control
*      it_special_groups             =     "" Field Groups
*      it_toolbar_excluding          =     "" Excluded Toolbar Standard Functions
*      it_hyperlink                  =     "" Hyperlinks
*      it_alv_graphics               =     "" Table of Structure DTC_S_TC
*      it_except_qinfo               =     "" Table for Exception Quickinfo
*      ir_salv_adapter               =     "" Interface ALV Adapter
    CHANGING
      it_outtab                     =  <table>   "" Output Table
      it_fieldcatalog               = lt_fieldcatalog    "" Field Catalog
*      it_sort                       =     "" Sort Criteria
*      it_filter                     =     "" Filter Criteria
    EXCEPTIONS
      invalid_parameter_combination = 1
      program_error                 = 2
      too_many_lines                = 3
      OTHERS                        = 4
  ).
  IF sy-subrc <> 0.
    MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno
               WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
  ENDIF.

* screen for alv grid display
  CALL SCREEN 9000.
*&---------------------------------------------------------------------*
*&      Module  STATUS_9000  OUTPUT
*&---------------------------------------------------------------------*
*       text
*----------------------------------------------------------------------*
MODULE status_9000 OUTPUT.
  DATA lt_extab TYPE slis_t_extab .
*  SET PF-STATUS 'xxxxxxxx'.
  SET PF-STATUS 'STANDARD_FULLSCREEN' OF PROGRAM 'SAPLSLVC_FULLSCREEN'."" EXCLUDING rt_extab[].
*  SET TITLEBAR 'xxx'.
ENDMODULE.
*&---------------------------------------------------------------------*
*&      Module  USER_COMMAND_9000  INPUT
*&---------------------------------------------------------------------*
*       text
*----------------------------------------------------------------------*
MODULE user_command_9000 INPUT.
  PERFORM user_command.
ENDMODULE.
MODULE user_cmd_exit_9000 INPUT.
  PERFORM scr_9000_exit.
ENDMODULE.

FORM user_command.

  DATA: l_okcode    LIKE sy-ucomm,
        ls_selfield TYPE slis_selfield.

  l_okcode = g_okcode.
  CLEAR g_okcode.

  CASE l_okcode.
    WHEN zif_git_report_alvgrid=>con_exit OR zif_git_report_alvgrid=>con_back OR zif_git_report_alvgrid=>con_canc.
      g_okcode = l_okcode.
      PERFORM scr_9000_exit.

    WHEN OTHERS.

  ENDCASE.

ENDFORM.

FORM scr_9000_exit.
  DATA: l_okcode LIKE sy-ucomm.

  l_okcode = g_okcode.
  CLEAR g_okcode.

  CASE l_okcode.
    WHEN zif_git_report_alvgrid=>con_exit OR zif_git_report_alvgrid=>con_back OR zif_git_report_alvgrid=>con_canc.
      CALL METHOD lr_alvgrid->zif_git_report_alvgrid~m_alv_grid->free.
      CALL METHOD lr_alvgrid->zif_git_report_alvgrid~m_alv_container->free.

      CALL METHOD cl_gui_cfw=>flush.

      CLEAR lr_alvgrid->zif_git_report_alvgrid~m_alv_container.
      CLEAR lr_alvgrid->zif_git_report_alvgrid~m_alv_grid.
*      CLEAR gr_events_d0100.

      SET SCREEN 0.
      LEAVE SCREEN.
  ENDCASE.
ENDFORM.
",5152,False,1099.2879164700103,median
"#include <WiFi.h>
#include <BME280.h>
#include <PubSubClient.h>
#include <U8g2lib.h>
#include <RunningMedian.h>

// Links to external libaries:
// https://github.com/e-radionicacom/BME280-Arduino-Library
// https://github.com/RobTillaart/Arduino/tree/master/libraries/RunningMedian

// Device name
String device_name = ""delux-ambient-sensor"";

// WLAN settings
const char* ssid = """";
const char* password = """";

// 0: Only Web server
// 1: Thingspeak
// 2: MQTT
// 3: Only display
int output = 0;

// MQTT settings
// If you want to use Thingspeak set mqtt_broker to ""mqtt.thingspeak.com""
//const char* mqtt_broker = """";
const char* mqtt_broker = ""mqtt.thingspeak.com"";
// Not needed for Thingspeak
const char* mqtt_username = """";
const char* mqtt_password = """";
int mqtt_port = 1883; // This is the default port for MQTT

// ThingSpeak settings
// Replace <YOUR-CHANNEL-ID> with your channel ID and <YOUR-CHANNEL-WRITEAPIKEY>
// with your write API key
const char* thingspeak_topic = ""channels/<YOUR-CHANNEL-ID>/publish/<YOUR-CHANNEL-WRITEAPIKEY>"";


// Pin for an additional LED
int led_pin = 2;

// Interval for sending MQTT messages in milliseconds
int interval = 60000;

// Interval to force the sending of MQTT messages
int force_interval = 300000;

// Interval for refresh display in milliseconds
int display_interval = 30000;


// Default MQTT topics (not needed for Thingspeak)
String humidity_topic = device_name + ""/humidity"";
String temperature_topic =  device_name + ""/temperature"";
String hall_topic =  device_name + ""/hall"";
String pressure_topic =  device_name + ""/pressure"";
String led_topic =  device_name + ""/led"";
String led_topic_set = device_name + ""/led/set"";

uint64_t chipid;

// Variables (no need to change)
float temperature = 0;
float humidity = 0;
float pressure = 0;
float hall = 0.0;
float diff_temperature = 0.5;
float diff_pressure = 1.0;
float diff_humidity = 3.0;
float diff_hall = 2.0;
long lastMsg = 0;
long lastForceMsg = 0;
long lastDisplay = 0;
bool forceMsg = false;
float old_temperature = 0.0;
float old_humidity = 0.0;
float old_pressure = 0.0;
float old_hall = 0.0;

// Settings and variables for touch functionality
int thresholdGlobal = 10;
int thresholdTouch0 = 0;
int thresholdTouch2 = 0;
int thresholdTouch3 = 0;
int thresholdTouch4 = 0;

int navigationDisplay = 1;

// Median for the Touch sensors
RunningMedian medianTouch0 = RunningMedian(5);
RunningMedian medianTouch2 = RunningMedian(5);
RunningMedian medianTouch3 = RunningMedian(5);
RunningMedian medianTouch4 = RunningMedian(5);

// Current WLAN status
int status = WL_IDLE_STATUS;

WiFiClient espClient;
PubSubClient mqtt_client(espClient);

WiFiServer server(80);
BME280 bme;

U8G2_SSD1306_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);

// Symbol temperatur for display
#define thermometer_width 26
#define thermometer_height 55
static const unsigned char thermometer_bits[] U8X8_PROGMEM = {
  0x00, 0x7c, 0x00, 0x00, 0x00, 0xff, 0x01, 0x00, 0x80, 0xff, 0x03, 0x00,
  0xc0, 0xff, 0x07, 0x00, 0xe0, 0xff, 0x0f, 0x00, 0xe0, 0x83, 0x0f, 0x00,
  0xf0, 0x01, 0x1f, 0x00, 0xf0, 0x01, 0x1f, 0x00, 0xf0, 0x01, 0x1f, 0x00,
  0xf0, 0x01, 0x1f, 0x00, 0xf0, 0x01, 0x1f, 0x00, 0xf0, 0x01, 0x1f, 0x00,
  0xf0, 0x01, 0x1f, 0x00, 0xf0, 0x01, 0x1f, 0x00, 0xf0, 0x01, 0x1f, 0x00,
  0xf0, 0x01, 0x1f, 0x00, 0xf0, 0x01, 0x1f, 0x00, 0xf0, 0x39, 0x1f, 0x00,
  0xf0, 0x39, 0x1f, 0x00, 0xf0, 0x39, 0x1f, 0x00, 0xf0, 0x39, 0x1f, 0x00,
  0xf0, 0x39, 0x1f, 0x00, 0xf0, 0x39, 0x1f, 0x00, 0xf0, 0x39, 0x1f, 0x00,
  0xf0, 0x39, 0x1f, 0x00, 0xf0, 0x39, 0x1f, 0x00, 0xf0, 0x39, 0x1f, 0x00,
  0xf0, 0x39, 0x1f, 0x00, 0xf0, 0x39, 0x1f, 0x00, 0xf0, 0x39, 0x1f, 0x00,
  0xf0, 0x39, 0x1f, 0x00, 0xf0, 0x39, 0x1f, 0x00, 0xf0, 0x39, 0x1f, 0x00,
  0xf8, 0x39, 0x3f, 0x00, 0xfc, 0x38, 0x7e, 0x00, 0x7e, 0x38, 0xfc, 0x00,
  0x3e, 0x38, 0xf8, 0x00, 0x1f, 0x7c, 0xf0, 0x01, 0x1f, 0xff, 0xf1, 0x01,
  0x0f, 0xff, 0xe1, 0x01, 0x8f, 0xff, 0xe3, 0x01, 0x8f, 0xff, 0xe3, 0x01,
  0x8f, 0xff, 0xe3, 0x01, 0x8f, 0xff, 0xe3, 0x01, 0x0f, 0xff, 0xe1, 0x01,
  0x1f, 0xff, 0xf1, 0x01, 0x1f, 0x7c, 0xf0, 0x01, 0x3e, 0x00, 0xf8, 0x00,
  0x7e, 0x00, 0xfc, 0x00, 0xfc, 0x01, 0x7f, 0x00, 0xf8, 0xff, 0x3f, 0x00,
  0xf0, 0xff, 0x1f, 0x00, 0xe0, 0xff, 0x0f, 0x00, 0x80, 0xff, 0x03, 0x00,
  0x00, 0xfe, 0x00, 0x00
};

// Drop symbol for display
#define humidity_width 35
#define humidity_height 40
static const unsigned char humidity_bits[] U8X8_PROGMEM = {
  0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00,
  0x00, 0x1e, 0x00, 0x38, 0x00, 0x00, 0x1f, 0x00, 0x78, 0x00, 0x00, 0x3f,
  0x00, 0x78, 0x00, 0x00, 0x3f, 0x00, 0xfc, 0x00, 0x80, 0x3f, 0x00, 0xfc,
  0x00, 0x80, 0x7b, 0x00, 0xfc, 0x00, 0x80, 0x73, 0x00, 0xfe, 0x00, 0xc0,
  0x73, 0x00, 0xce, 0x01, 0xc0, 0xf3, 0x00, 0xcf, 0x01, 0xc0, 0xf1, 0x00,
  0xcf, 0x03, 0xe0, 0xe1, 0x00, 0xc7, 0x03, 0xe0, 0xe0, 0x01, 0x87, 0x03,
  0xe0, 0xc0, 0x01, 0xcf, 0x03, 0xf0, 0xc0, 0x03, 0xff, 0x03, 0x70, 0xc0,
  0x03, 0xfe, 0x01, 0x70, 0x80, 0x03, 0xfc, 0x60, 0x70, 0x80, 0x03, 0x30,
  0xf0, 0x70, 0x80, 0x03, 0x00, 0xf0, 0x70, 0xc0, 0x03, 0x00, 0xf0, 0xf1,
  0xc0, 0x03, 0x00, 0xf8, 0xe1, 0xf3, 0x01, 0x00, 0xf8, 0xc1, 0xff, 0x00,
  0x00, 0xf8, 0xc3, 0x7f, 0x00, 0x00, 0xfc, 0x03, 0x1e, 0x00, 0x00, 0xbc,
  0x03, 0x00, 0x00, 0x00, 0x9c, 0x07, 0x00, 0x00, 0x00, 0x1e, 0x07, 0x00,
  0x00, 0x00, 0x0e, 0x07, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00, 0x00,
  0x0f, 0x0e, 0x00, 0x00, 0x00, 0x07, 0x0e, 0x00, 0x00, 0x00, 0x07, 0x0e,
  0x00, 0x00, 0x00, 0x07, 0x0e, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x00, 0x00,
  0x00, 0x9f, 0x0f, 0x00, 0x00, 0x00, 0xfe, 0x07, 0x00, 0x00, 0x00, 0xfc,
  0x03, 0x00, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00
};


// IP to String
String toStringIp(IPAddress ip) {
  String res = """";
  for (int i = 0; i < 3; i++) {
    res += String((ip >> (8 * i)) & 0xFF) + ""."";
  }
  res += String(((ip >> 8 * 3)) & 0xFF);
  return res;
}

// Check it a value changed more than the given value
bool checkBound(float newValue, float prevValue, float maxDiff) {
  return newValue < prevValue - maxDiff || newValue > prevValue + maxDiff;
}

// https://stackoverflow.com/questions/9072320/split-string-into-string-array
String splitString(String data, char separator, int index) {
  int found = 0;
  int strIndex[] = {0, -1};
  int maxIndex = data.length() - 1;

  for (int i = 0; i <= maxIndex && found <= index; i++) {
    if (data.charAt(i) == separator || i == maxIndex) {
      found++;
      strIndex[0] = strIndex[1] + 1;
      strIndex[1] = (i == maxIndex) ? i + 1 : i;
    }
  }
  return found > index ? data.substring(strIndex[0], strIndex[1]) : """";
}

// Callback for MQTT messages
void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print(""Message arrived ["");
  Serial.print(topic);
  Serial.print(""] "");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();

  if ((char)payload[0] == '1') {
    digitalWrite(led_pin, LOW);
  } else {
    digitalWrite(led_pin, HIGH);
  }
}

void reconnect() {
  // Loop until the device is reconnected
  while (!mqtt_client.connected()) {
    Serial.print(""MQTT broker: "");
    Serial.println(mqtt_broker);
    Serial.print(""Attempting MQTT connection..."");
    // Attempt to connect with a random Client ID
    if (mqtt_client.connect((device_name + random(1000)).c_str())) {
      Serial.println(""connected"");
      if (output == 2) {
        // Once connected, publish an announcement...
        mqtt_client.publish(device_name.c_str(), ""connected"");
        // Subscribe to topic for setting the state of the LED
        mqtt_client.subscribe(led_topic_set.c_str());
      }
    } else {
      Serial.print(""failed, rc="");
      Serial.print(mqtt_client.state());
      Serial.println("" try again in 5 seconds"");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}

// Show the temperature
void anzeigeTemperatur() {
  navigationDisplay = 1;
  u8g2.clearBuffer();
  u8g2.drawXBM(0 , 4, thermometer_width, thermometer_height,  thermometer_bits);
  u8g2.setFont(u8g2_font_helvB18_tf);
  u8g2.setCursor(45, 44);
  u8g2.print(temperature, 1);
  u8g2.print((char)176);
  u8g2.print(""C"");
  u8g2.sendBuffer();
}

// Show the humitidy
void anzeigeFeuchte() {
  navigationDisplay = 2;
  u8g2.clearBuffer();
  u8g2.drawXBM(0 , 12, humidity_width, humidity_height,  humidity_bits);
  u8g2.setFont(u8g2_font_helvB18_tf);
  u8g2.setCursor(45, 44);
  u8g2.print(humidity, 1);
  u8g2.print(""%"");
  u8g2.sendBuffer();

}

// Show the pressure
void anzeigeDruck() {
  navigationDisplay = 3;
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_helvB18_tf);
  u8g2.setCursor(8, 46);
  u8g2.print(pressure, 1);
  u8g2.print("" hPa"");
  u8g2.sendBuffer();
}

// Show all
void anzeigeAll() {
  navigationDisplay = 4;
  u8g2.clearBuffer();
  u8g2.setFont(u8g2_font_helvB18_tf);
  u8g2.setCursor(0, 19);
  u8g2.print(temperature, 1);
  u8g2.print("" "");
  u8g2.print((char)176);
  u8g2.print(""C"");
  u8g2.setCursor(0, 41);
  u8g2.print(humidity, 1);
  u8g2.print(""  %"");
  u8g2.setCursor(0, 64);
  u8g2.print(pressure, 1);
  u8g2.print("" hPa"");
  u8g2.sendBuffer();
}

void setup() {
  // Set up the Serial Monitor
  Serial.begin(115200);
  pinMode(led_pin, OUTPUT);
  delay(10);

  chipid = ESP.getEfuseMac();

  bme.settings(0, 3, 0, 0, 3, 3, 3);
  while (bme.begin()) {
    Serial.println(""Could not find BME280 sensor on the I2C bus"");
    delay(1000);
  }

  u8g2.begin();                              // OLED Display Initialisieren
  u8g2.setDrawColor(1);                      // Definition for the color of XBM images
  u8g2.setBitmapMode(1);                     // Mode for XBM images

  // Median
  while (medianTouch0.getCount() < medianTouch0.getSize()) {
    medianTouch0.add(touchRead(T0));
    medianTouch2.add(touchRead(T2));
    medianTouch3.add(touchRead(T3));
    medianTouch4.add(touchRead(T4));
  }

  thresholdTouch0 = medianTouch0.getMedian() - thresholdGlobal;
  thresholdTouch2 = medianTouch2.getMedian() - thresholdGlobal;
  thresholdTouch3 = medianTouch3.getMedian() - thresholdGlobal;
  thresholdTouch4 = medianTouch4.getMedian() - thresholdGlobal;

  Serial.println();
  Serial.print(""Connecting to "");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(""."");
  }
  Serial.println("""");
  Serial.println(""WiFi connected"");
  Serial.print(""IP address: "");
  Serial.println(WiFi.localIP());

  // Start HTTP server
  server.begin();
  Serial.println(""Web server started"");

  // Setup the MQTT client
  if (output == 1 || output == 2) {
    mqtt_client.setServer(mqtt_broker, mqtt_port);
  }
  // Callback is not needed for Thingspeak
  if (output == 2) {
    mqtt_client.setCallback(callback);
  }
}

void loop() {
  // Read values from sensor
  temperature = bme.readTemp();
  pressure = bme.readPressure() / 100.0F;
  humidity = bme.readHumidity();
  hall = hallRead();

  medianTouch0.add(touchRead(T0));
  medianTouch2.add(touchRead(T2));
  medianTouch3.add(touchRead(T3));
  medianTouch4.add(touchRead(T4));

  // Touch check
  if (medianTouch0.getMedian() < thresholdTouch0) {
    Serial.println(""Touch0"");
    if (navigationDisplay != 1) {
      anzeigeTemperatur();
    }
  } else if (medianTouch2.getMedian() < thresholdTouch2) {
    Serial.println(""Touch2"");
    if (navigationDisplay != 2) {
      anzeigeFeuchte();
    }
  } else if (medianTouch3.getMedian() < thresholdTouch3) {
    Serial.println(""Touch3"");
    if (navigationDisplay != 3) {
      anzeigeDruck();
    }
  } else if (medianTouch4.getMedian() < thresholdTouch4) {
    Serial.println(""Touch4"");
    if (navigationDisplay != 4) {
      anzeigeAll();
    }
  }

  if (millis() - lastDisplay > display_interval) {
    lastDisplay = millis();
    switch (navigationDisplay) {
      case 1:
        anzeigeTemperatur();
        break;
      case 2:
        anzeigeFeuchte();
        break;
      case 3:
        anzeigeDruck();
        break;
      case 4:
        anzeigeAll();
        break;
      default:
        break;
    }
  }

  if (output != 3) {
    WiFiClient client = server.available();   // Listen for incoming client requests
    if (client) {                             // If you get a client,
      while (client.connected()) {            // Loop while the client's connected
        if (client.available()) {             // If there's bytes to read from the client,
          String request = client.readString();  // Read client request
          Serial.println(""-- Complete HTTP method -------------------------------"");
          Serial.println(request);
          Serial.println(""-- HTTP method -------------------------------"");
          String method = splitString(request, '\\r', 0);
          Serial.println(method);
          Serial.println(""-- POST data -------------------------------"");
          String post_data = splitString(request, '\\r\\n\\n', 7);
          Serial.println(post_data);
          Serial.println();
          client.flush();

          if (method.equals(""GET /favicon.ico HTTP/1.1"")) {
            Serial.println(""Get the favicon.ico"");
          }

          else if (method.equals(""GET / HTTP/1.1"")) {
            Serial.println(""Request for /"");
            client.println(""HTTP/1.1 200 OK"");
            client.println(""Content-type:text/html"");
            client.println();
            client.println(""<!DOCTYPE HTML><html><head><meta name=\\""viewport\\"" content=\\""width=device-width, initial-scale=1\\"">"");
            client.println(""</head><body style='font-family: Verdana,Geneva,sans-serif;'><center>"");
            client.println(""<p><b><a href='/'>Ambient Sensor</a></b> | <a href='/api'>RESTful API</a></p>"");
            client.println(""<h1>Overview</h1><p>"");

            // Device details
            client.println(""<table><tr><th align='left'>Device</th></tr>"");
            client.println(String(""<tr><td>Device name:</td><td>"") + device_name + ""</td></tr>"");
            client.print(""<tr><td>Chip ID:</td><td>"");
            client.printf(""%04X"", (uint16_t)(chipid >> 32));
            client.printf(""%08X\\n"", (uint32_t)chipid);
            client.println(""</td></tr>"");
            client.println(""<tr><td>Restart:</td><td><a href=\\""/api/device/reboot\\"">yes</a></td></tr>"");
            //client.println(String(""<tr><td>Uptime</td><td>"") + timeClient.getFormattedTime() + ""</td></tr>"");
            client.println(""</table>"");
            client.println(""<br />"");

            // Sensor values
            client.println(""<table><tr><th align='left'>Sensors</th></tr>"");
            client.println(String(""<tr><td>Temperature:</td><td>"") + temperature + "" C</td></tr>"");
            client.println(String(""<tr><td>Humidity:</td><td>"") + humidity + "" % RH</td></tr>"");
            client.println(String(""<tr><td>Pressure:</td><td>"") + pressure + "" hPa</td></tr>"");
            client.println(String(""<tr><td>Hall:</td><td>"") + hall + ""</td></tr>"");
            //client.println(String(""<tr><td>xxxx</td><td>xxx</td></tr>"");
            client.println(""</table>"");
            client.println(""<br />"");

            // the content of the HTTP response follows the header:
            client.print(String(""<b>LED</b> (Pin "") + led_pin + ""):&nbsp;"");
            if (digitalRead(led_pin) == HIGH) {
              client.print(""on"");
            } else {
              client.print(""off"");
            }
            client.println(""&nbsp;(Turn <a href=\\""/api/led/on\\"">on</a> or <a href=\\""/api/led/off\\"">off</a>)"");
            client.println(""<br />"");

            client.println(""<hr>"");
            client.println(""<p>More sensors, actuators, and kits are available in the online shop of <a href='https://www.bastelgarage.ch'>Bastelgarage.ch</a>.</p>"");
            client.println(""</center></body></html>"");
            // The HTTP response ends with another blank line:
            client.println();
            // break out of the while loop:
            client.stop();
          }
          // RESTful API section
          else if (method.equals(""GET /api HTTP/1.1"")) {
            Serial.println(""Request for /api"");
            client.println(""HTTP/1.1 200 OK"");
            client.println(""Content-type:text/html"");
            client.println();
            client.println(""<!DOCTYPE HTML><html><head><meta name=\\""viewport\\"" content=\\""width=device-width, initial-scale=1\\"">"");
            client.println(""</head><body style='font-family: Verdana,Geneva,sans-serif;'><center>"");
            client.println(""<p><b><a href='/'>Ambient Sensor</a></b> | <a href='/api'>RESTful API</a></p>"");
            client.println(""<h1>RESTful API</h1><p>"");
            client.println(""<p>The RESTful API let you integrate your Measuring Box in your own home automation system or into third-party tools.</p>"");
            client.println(""<br />"");

            // API end points
            client.println(""<table><tr><th align='left'>End points</th><th align='left'>URL</th></tr>"");
            client.println(""<tr><td>All values:</td><td><a href=\\""api/states\\"">api/states</a></td></tr>"");
            client.println(""<tr><td>Temperature:</td><td><a href=\\""api/temperature\\"">api/temperature</a></td></tr>"");
            client.println(""<tr><td>Humidity:</td><td><a href=\\""api/humidity\\"">api/humidity</a></td></tr>"");
            client.println(""<tr><td>Pressure:</td><td><a href=\\""api/pressure\\"">api/pressure</a></td></tr>"");
            client.println(""<tr><td>Hall:</td><td><a href=\\""api/hall\\"">api/hall</a></td></tr>"");
            client.println(""<tr><td>LED:</td><td><a href=\\""api/led\\"">api/led</a></td></tr>"");
            // client.println(""<tr><td>xxxx</td><td>xxx</td></tr>"");
            client.println(""</table>"");
            client.println(""<br />"");
            client.println(""<p>The states can be retrieved by HTTP GET requests. For the temperature the command-line tool <code>curl</code> could be used.</p>"");
            client.println(String(""<p>eg. <code>$ curl "") + toStringIp(WiFi.localIP()) + ""/api/temperature</code></p>"");
            client.println(""<p>To change the state of the LED, issue a HTTP POST requests."");
            client.println(""As browsers usualy don't support POST requests, GET requests are available to <code>/api/led/on</code> to switch the LED on and <code>api/led/off</code> to switch it off.</p>"");

            client.println(String(""<p>eg. <code>$ curl -d \\""{'state': 1}\\"" "") + toStringIp(WiFi.localIP()) + ""/api/led</code></p>"");
            client.println(""</center></body></html>"");
          }

          else if (method.equals(""GET /api/led HTTP/1.1"")) {
            client.println(""HTTP/1.1 200 OK"");
            client.println(""Content-Type: application/json"");
            client.println();
            client.print(""{\\""state\\"": "");
            if (digitalRead(led_pin) == HIGH) {
              client.print(1);
            } else {
              client.print(0);
            }
            client.println(""}"");
            client.stop();
          }
          else if (method.equals(""POST /api/led HTTP/1.1"")) {
            char value = post_data.charAt(10);
            if (value == '1') {
              Serial.println(""Switch on LED"");
              digitalWrite(led_pin, HIGH);
            } else {
              Serial.println(""Switch off LED"");
              digitalWrite(led_pin, LOW);
            }
            client.println(""HTTP/1.1 200 OK"");
            client.println(""Content-Type: application/json"");
            client.println();
            client.print(""{\\""state\\"": "");
            if (digitalRead(led_pin) == HIGH) {
              client.print(1);
            } else {
              client.print(0);
            }
            client.println(""}"");
            client.stop();
          }
          // Brosers don't do POST requests
          else if (method.equals(""GET /api/led/on HTTP/1.1"")) {
            Serial.println(""Switch on LED"");
            digitalWrite(led_pin, HIGH);
            client.println(""HTTP/1.1 200 OK"");
            client.println(""Content-Type: application/json"");
            client.println();
            client.println(""{\\""state\\"": 1}"");
            client.println();
            client.stop();
          }
          else if (method.equals(""GET /api/led/off HTTP/1.1"")) {
            Serial.println(""Switch off LED"");
            digitalWrite(led_pin, LOW);
            client.println(""HTTP/1.1 200 OK"");
            client.println(""Content-Type: application/json"");
            client.println();
            client.println(""{\\""state\\"": 0}"");
            client.println();
            client.stop();
          }
          else if (method.equals(""GET /api/states HTTP/1.1"")) {
            client.println(""HTTP/1.1 200 OK"");
            client.println(""Content-Type: application/json"");
            client.println();

            client.print(""{"");
            client.println(String(""\\""device\\"":\\"""") + device_name + ""\\"","");

            client.println(""\\""states\\"": {"");
            client.println(String(""\\""temperature\\"":"") + temperature + "","");
            client.println(String(""\\""pressure\\"":"") + pressure + "","");
            client.println(String(""\\""humidity\\"":"") + humidity + "","");
            client.println(String(""\\""hall\\"":"") + hall + "","");
            client.println(String(""\\""led\\"":"") + digitalRead(led_pin));
            client.print(""}}"");
            client.println();
            client.stop();
          }
          else if (method.equals(""GET /api/hall HTTP/1.1"")) {
            client.println(""HTTP/1.1 200 OK"");
            client.println(""Content-Type: application/json"");
            client.println();
            client.println(String(""{\\""value\\"":"") + hallRead() + ""}"");
            client.println();
            client.stop();
          }
          else if (method.equals(""GET /api/temperature HTTP/1.1"")) {
            client.println(""HTTP/1.1 200 OK"");
            client.println(""Content-Type: application/json"");
            client.println();
            client.println(String(""{\\""value\\"":"") + pressure + ""}"");
            client.println();
            client.stop();
          }
          else if (method.equals(""GET /api/humidity HTTP/1.1"")) {
            client.println(""HTTP/1.1 200 OK"");
            client.println(""Content-Type: application/json"");
            client.println();
            client.println(String(""{\\""value\\"":"") + humidity + ""}"");
            client.println();
            client.stop();
          }
          else if (method.equals(""GET /api/pressure HTTP/1.1"")) {
            client.println(""HTTP/1.1 200 OK"");
            client.println(""Content-Type: application/json"");
            client.println();
            client.println(String(""{\\""value\\"":"") + pressure + ""}"");
            client.println();
            client.stop();
          }
          // Browser don't do HTTP POST requests
          else if ((method.equals(""POST /api/device/reboot HTTP/1.1"")) or (method.equals(""GET /api/device/reboot HTTP/1.1""))) {
            Serial.println(""rebooting..."");
            ESP.restart();
            client.println(""HTTP/1.1 200 OK"");
            client.println(""Content-Type: application/json"");
            client.println();
            client.println(""{\\""state\\"": \\""rebooting\\""}"");
            client.stop();
          }
          else {
            client.println(""HTTP/1.1 404 OK"");
            client.println(""Content-type:text/html"");
            client.println();
            client.println(""<!DOCTYPE HTML><html><head><meta name=\\""viewport\\"" content=\\""width=device-width, initial-scale=1\\"">"");
            client.println(""</head><body style='font-family: Verdana,Geneva,sans-serif;'><center>"");
            client.println(""<p><b><a href='/'>Ambient sensor</a></b> | <a href='/api'>RESTful API</a></p>"");
            client.println(""<h1>Page not available</h1><p>"");
            client.println(""</center></body></html>"");
            client.println();
            client.stop();
          }
          client.stop();
        }
      }
      // Close the connection
      client.stop();
      //Serial.println(""Client disonnected"");
    }
    // MQTT
    if (output == 1 || output == 2) {
      if (!mqtt_client.connected()) {
        reconnect();
      }
      mqtt_client.loop();
    }
    long now = millis();
    if (now - lastMsg > interval) {
      lastMsg = now;
      // MQTT broker could go away and come back at any timeso doing a forced publish to
      // make sure something shows up within the first 5 minutes after a reset
      if (now - lastForceMsg > force_interval) {
        lastForceMsg = now;
        forceMsg = true;
        Serial.println(""Forcing publish every 5 minutes..."");
      }

      // Sending data to Thingspeak
      if (output == 1) {
        String data = String(""field1="" + String(temperature, 2) + ""&field2="" + String(pressure, 2) + ""&field3="" + String(humidity, 2));
        // Get the data string length
        int length = data.length();
        char msgBuffer[length + 1];
        // Convert data string to character buffer
        data.toCharArray(msgBuffer, length + 1);
        Serial.println(msgBuffer);
        mqtt_client.publish(thingspeak_topic, msgBuffer);
      }

      // Sending MQTT messages
      if (output == 2) {
        if (checkBound(temperature, old_temperature, diff_temperature) || forceMsg) {
          old_temperature = temperature;
          mqtt_client.publish(temperature_topic.c_str(), String(old_temperature).c_str(), true);
        }
        if (checkBound(humidity, old_humidity, diff_humidity) || forceMsg) {
          old_humidity = humidity;
          mqtt_client.publish(humidity_topic.c_str(), String(old_humidity).c_str(), true);
        }
        if (checkBound(pressure, old_pressure, diff_pressure) || forceMsg) {
          old_pressure = pressure;
          mqtt_client.publish(pressure_topic.c_str(), String(old_pressure).c_str(), true);
        }
      }
      forceMsg = false;
    }
  }
}

",8338,False,1351.9763920981484,median
"CLASS zcl_gtt_mia_ctp_snd_sh_to_dli DEFINITION
  PUBLIC
  INHERITING FROM zcl_gtt_mia_ctp_snd
  CREATE PRIVATE .

  PUBLIC SECTION.

    CLASS-METHODS get_instance
      RETURNING
        VALUE(ro_sender) TYPE REF TO zcl_gtt_mia_ctp_snd_sh_to_dli
      RAISING
        cx_udm_message .
    METHODS prepare_idoc_data
      IMPORTING
        !io_ship_data TYPE REF TO zcl_gtt_mia_ctp_shipment_data
      RAISING
        cx_udm_message .
  PROTECTED SECTION.

    METHODS get_aotype_restriction_id
        REDEFINITION .

    METHODS get_object_type
        REDEFINITION .

  PRIVATE SECTION.

    CONSTANTS:
      BEGIN OF cs_mapping,
        vbeln TYPE /saptrx/paramname VALUE 'YN_DLV_NO',
        posnr TYPE /saptrx/paramname VALUE 'YN_DLV_ITEM_NO',
      END OF cs_mapping .

    METHODS fill_idoc_appobj_ctabs
      IMPORTING
        !is_aotype    TYPE zif_gtt_mia_ctp_tor_types=>ts_aotype
        !is_lips      TYPE zcl_gtt_mia_ctp_shipment_data=>ts_lips
      CHANGING
        !cs_idoc_data TYPE zif_gtt_mia_ctp_tor_types=>ts_idoc_data
      RAISING
        cx_udm_message .
    METHODS fill_idoc_control_data
      IMPORTING
        !is_aotype    TYPE zif_gtt_mia_ctp_tor_types=>ts_aotype
        !is_ship      TYPE zcl_gtt_mia_ctp_shipment_data=>ts_shipment_merge
        !is_likp      TYPE zcl_gtt_mia_ctp_shipment_data=>ts_likpex
        !is_lips      TYPE zcl_gtt_mia_ctp_shipment_data=>ts_lips
        !is_stops     TYPE zcl_gtt_mia_ctp_shipment_data=>ts_stops
      CHANGING
        !cs_idoc_data TYPE zif_gtt_mia_ctp_tor_types=>ts_idoc_data
      RAISING
        cx_udm_message .
    METHODS fill_idoc_exp_event
      IMPORTING
        !is_aotype    TYPE zif_gtt_mia_ctp_tor_types=>ts_aotype
        !is_ship      TYPE zcl_gtt_mia_ctp_shipment_data=>ts_shipment_merge
        !is_likp      TYPE zcl_gtt_mia_ctp_shipment_data=>ts_likpex
        !is_lips      TYPE zcl_gtt_mia_ctp_shipment_data=>ts_lips
        !is_stops     TYPE zcl_gtt_mia_ctp_shipment_data=>ts_stops
      CHANGING
        !cs_idoc_data TYPE zif_gtt_mia_ctp_tor_types=>ts_idoc_data
      RAISING
        cx_udm_message .
    METHODS fill_idoc_tracking_id
      IMPORTING
        !is_aotype    TYPE zif_gtt_mia_ctp_tor_types=>ts_aotype
        !is_ship      TYPE zcl_gtt_mia_ctp_shipment_data=>ts_shipment_merge
        !is_likp      TYPE zcl_gtt_mia_ctp_shipment_data=>ts_likpex
        !is_lips      TYPE zcl_gtt_mia_ctp_shipment_data=>ts_lips
      CHANGING
        !cs_idoc_data TYPE zif_gtt_mia_ctp_tor_types=>ts_idoc_data
      RAISING
        cx_udm_message .
    METHODS get_shipment_stop
      IMPORTING
        !is_stops      TYPE zcl_gtt_mia_ctp_shipment_data=>ts_stops
        !is_vbfa       TYPE zcl_gtt_mia_ctp_shipment_data=>ts_vbfaex
        !iv_arrival    TYPE abap_bool
      RETURNING
        VALUE(rv_stop) TYPE zif_gtt_mia_app_types=>tv_stopid .
    CLASS-METHODS get_delivery_item_tracking_id
      IMPORTING
        !is_lips              TYPE zcl_gtt_mia_ctp_shipment_data=>ts_lips
      RETURNING
        VALUE(rv_tracking_id) TYPE /saptrx/trxid
      RAISING
        cx_udm_message.
    METHODS is_pod_relevant
      IMPORTING
        !is_ship         TYPE zcl_gtt_mia_ctp_shipment_data=>ts_shipment_merge
        !is_lips         TYPE zcl_gtt_mia_ctp_shipment_data=>ts_lips
        !is_stops        TYPE zif_gtt_mia_app_types=>ts_stops
      RETURNING
        VALUE(rv_result) TYPE abap_bool
      RAISING
        cx_udm_message.
ENDCLASS.



CLASS ZCL_GTT_MIA_CTP_SND_SH_TO_DLI IMPLEMENTATION.


  METHOD fill_idoc_appobj_ctabs.

    cs_idoc_data-appobj_ctabs = VALUE #( BASE cs_idoc_data-appobj_ctabs (
      trxservername = cs_idoc_data-trxserv-trx_server_id
      appobjtype    = is_aotype-aot_type
      appobjid      = get_delivery_item_tracking_id(
                        is_lips = is_lips )
    ) ).

  ENDMETHOD.


  METHOD fill_idoc_control_data.

    DATA: lt_control    TYPE /saptrx/bapi_trk_control_tab .

    "" DLV Item key data (obligatory)
    lt_control  = VALUE #(
      (
        paramname = cs_mapping-vbeln
        value     = zcl_gtt_mia_dl_tools=>get_formated_dlv_number(
                      ir_likp = REF #( is_lips ) )
      )
      (
        paramname = cs_mapping-posnr
        value     = zcl_gtt_mia_dl_tools=>get_formated_dlv_item(
                      ir_lips = REF #( is_lips ) )
      )
      (
        paramname = zif_gtt_mia_ef_constants=>cs_system_fields-actual_bisiness_timezone
        value     = zcl_gtt_mia_tools=>get_system_time_zone( )
      )
      (
        paramname = zif_gtt_mia_ef_constants=>cs_system_fields-actual_bisiness_datetime
        value     = |0{ sy-datum }{ sy-uzeit }|
      )
      (
        paramname = zif_gtt_mia_ef_constants=>cs_system_fields-actual_technical_timezone
        value     = zcl_gtt_mia_tools=>get_system_time_zone( )
      )
      (
        paramname = zif_gtt_mia_ef_constants=>cs_system_fields-actual_technical_datetime
        value     = |0{ sy-datum }{ sy-uzeit }|
      )
    ).

    "" fill technical data into all control data records
    LOOP AT lt_control ASSIGNING FIELD-SYMBOL(<ls_control>).
      <ls_control>-appsys     = mv_appsys.
      <ls_control>-appobjtype = is_aotype-aot_type.
      <ls_control>-appobjid   = get_delivery_item_tracking_id(
                                  is_lips = is_lips ).
    ENDLOOP.

    cs_idoc_data-control  = VALUE #( BASE cs_idoc_data-control
                                     ( LINES OF lt_control ) ).

  ENDMETHOD.


  METHOD fill_idoc_exp_event.

    DATA: lt_exp_event      TYPE /saptrx/bapi_trk_ee_tab,
          lt_exp_event_dlv  TYPE /saptrx/bapi_trk_ee_tab,
          lv_milestonenum   TYPE /saptrx/seq_num VALUE 1,
          lv_tknum          TYPE tknum.

    "" delivery item events
    zcl_gtt_mia_ctp_tools=>get_delivery_item_planned_evt(
      EXPORTING
        iv_appsys    = mv_appsys
        is_aotype    = is_aotype
        is_likp      = CORRESPONDING #( is_likp )
        is_lips      = CORRESPONDING #( is_lips )
      IMPORTING
        et_exp_event = lt_exp_event_dlv ).

    LOOP AT lt_exp_event_dlv TRANSPORTING NO FIELDS
      WHERE ( milestone = zif_gtt_mia_app_constants=>cs_milestone-sh_arrival OR
              milestone = zif_gtt_mia_app_constants=>cs_milestone-sh_departure OR
              milestone = zif_gtt_mia_app_constants=>cs_milestone-sh_pod ).
      DELETE lt_exp_event_dlv.
    ENDLOOP.

    "" shipment events
    LOOP AT is_stops-watching ASSIGNING FIELD-SYMBOL(<ls_watching>)
      WHERE vbeln = is_lips-vbeln.

      IF lv_tknum <> <ls_watching>-stopid(10).
        lv_tknum        = <ls_watching>-stopid(10).
        lv_milestonenum = 1.
      ENDIF.

      READ TABLE is_stops-stops ASSIGNING FIELD-SYMBOL(<ls_stops>)
        WITH KEY stopid = <ls_watching>-stopid
                 loccat = <ls_watching>-loccat.
      IF sy-subrc = 0.
        "" Departure / Arrival
        lt_exp_event = VALUE #( BASE lt_exp_event (
            milestone         = COND #( WHEN <ls_watching>-loccat = zif_gtt_mia_app_constants=>cs_loccat-departure
                                          THEN zif_gtt_mia_app_constants=>cs_milestone-sh_departure
                                          ELSE zif_gtt_mia_app_constants=>cs_milestone-sh_arrival )
            locid2            = <ls_stops>-stopid_txt
            loctype           = <ls_stops>-loctype
            locid1            = zcl_gtt_mia_tools=>get_pretty_location_id(
                                  iv_locid   = <ls_stops>-locid
                                  iv_loctype = <ls_stops>-loctype )
            evt_exp_datetime  = <ls_stops>-pln_evt_datetime
            evt_exp_tzone     = <ls_stops>-pln_evt_timezone
            milestonenum      = lv_milestonenum
        ) ).
        ADD 1 TO lv_milestonenum.

        "" POD
        IF <ls_stops>-loccat  = zif_gtt_mia_app_constants=>cs_loccat-arrival AND
           <ls_stops>-loctype = zif_gtt_mia_ef_constants=>cs_loc_types-plant AND
           is_pod_relevant( is_ship  = is_ship
                            is_lips  = is_lips
                            is_stops = <ls_stops> ) = abap_true.

          lt_exp_event = VALUE #( BASE lt_exp_event (
              milestone         = zif_gtt_mia_app_constants=>cs_milestone-sh_pod
              locid2            = <ls_stops>-stopid_txt
              loctype           = <ls_stops>-loctype
              locid1            = zcl_gtt_mia_tools=>get_pretty_location_id(
                                    iv_locid   = <ls_stops>-locid
                                    iv_loctype = <ls_stops>-loctype )
              evt_exp_datetime  = <ls_stops>-pln_evt_datetime
              evt_exp_tzone     = <ls_stops>-pln_evt_timezone
              milestonenum      = lv_milestonenum
          ) ).

          ADD 1 TO lv_milestonenum.

        ENDIF.
      ELSE.
        MESSAGE e005(zgtt_mia)
          WITH |{ <ls_watching>-stopid }{ <ls_watching>-loccat }| 'STOPS'
          INTO DATA(lv_dummy).
        zcl_gtt_mia_tools=>throw_exception( ).
      ENDIF.
    ENDLOOP.

    "" fill sequence number in DLV events
    lv_milestonenum   = zcl_gtt_mia_tools=>get_next_sequence_id(
                          it_expeventdata = lt_exp_event ).

    LOOP AT lt_exp_event_dlv ASSIGNING FIELD-SYMBOL(<ls_exp_event_dlv>).
      <ls_exp_event_dlv>-milestonenum   = lv_milestonenum.
      ADD 1 TO lv_milestonenum.
    ENDLOOP.

    lt_exp_event    = VALUE #( BASE lt_exp_event
                                ( LINES OF lt_exp_event_dlv ) ).

    IF lt_exp_event[] IS INITIAL.
      lt_exp_event = VALUE #( (
          milestone         = ''
          locid2            = ''
          loctype           = ''
          locid1            = ''
          evt_exp_datetime  = '000000000000000'
          evt_exp_tzone     = ''
      ) ).
    ENDIF.

    LOOP AT lt_exp_event ASSIGNING FIELD-SYMBOL(<ls_exp_event>).
      <ls_exp_event>-appsys         = mv_appsys.
      <ls_exp_event>-appobjtype     = is_aotype-aot_type.
      <ls_exp_event>-appobjid       = get_delivery_item_tracking_id(
                                        is_lips = is_lips ).
      <ls_exp_event>-language       = sy-langu.
      <ls_exp_event>-evt_exp_tzone  = zcl_gtt_mia_tools=>get_system_time_zone(  ).
    ENDLOOP.

    cs_idoc_data-exp_event = VALUE #( BASE cs_idoc_data-exp_event
                                      ( LINES OF lt_exp_event ) ).

  ENDMETHOD.


  METHOD fill_idoc_tracking_id.

*    ""another tip is that: for tracking ID type 'SHIPMENT_ORDER' of delivery header,
*    ""and for tracking ID type 'RESOURCE' of shipment header,
*    ""DO NOT enable START DATE and END DATE

    DATA:
      lv_tmp_dlvittrxcod TYPE /saptrx/trxcod,
      lv_dlvittrxcod     TYPE /saptrx/trxcod.

    lv_dlvittrxcod = zif_gtt_mia_app_constants=>cs_trxcod-dl_position.

    TRY.
        CALL FUNCTION 'ZGTT_SOF_GET_TRACKID'
          EXPORTING
            iv_type        = is_aotype-aot_type
            iv_app         = 'MIA'
          IMPORTING
            ev_dlvittrxcod = lv_tmp_dlvittrxcod.

        IF lv_tmp_dlvittrxcod IS NOT INITIAL.
          lv_dlvittrxcod = lv_tmp_dlvittrxcod.
        ENDIF.

      CATCH cx_sy_dyn_call_illegal_func.
    ENDTRY.

    "" Delivery Item
    cs_idoc_data-tracking_id    = VALUE #( BASE cs_idoc_data-tracking_id (
      appsys      = mv_appsys
      appobjtype  = is_aotype-aot_type
      appobjid    = get_delivery_item_tracking_id(
                      is_lips = is_lips )
      trxcod      = lv_dlvittrxcod
      trxid       = get_delivery_item_tracking_id(
                      is_lips = is_lips )
      timzon      = zcl_gtt_mia_tools=>get_system_time_zone( )
    ) ).

  ENDMETHOD.


  METHOD get_aotype_restriction_id.

    rv_rst_id   = 'SH_TO_IDLI'.

  ENDMETHOD.


  METHOD get_delivery_item_tracking_id.

    rv_tracking_id  = zcl_gtt_mia_dl_tools=>get_tracking_id_dl_item(
                        ir_lips = REF #( is_lips ) ).

  ENDMETHOD.


  METHOD get_instance.

    DATA(lt_trk_obj_type) = VALUE zif_gtt_mia_ctp_tor_types=>tt_trk_obj_type(
       ( zif_gtt_mia_ef_constants=>cs_trk_obj_type-esc_shipmt )
       ( zif_gtt_mia_ef_constants=>cs_trk_obj_type-esc_deliv )
    ).

    IF is_gtt_enabled( it_trk_obj_type = lt_trk_obj_type ) = abap_true.
      ro_sender  = NEW #( ).

      ro_sender->initiate( ).
    ELSE.
      MESSAGE e006(zgtt_mia) INTO DATA(lv_dummy).
      zcl_gtt_mia_tools=>throw_exception( ).
    ENDIF.

  ENDMETHOD.


  METHOD get_object_type.

    rv_objtype  = zif_gtt_mia_ef_constants=>cs_trk_obj_type-esc_deliv.

  ENDMETHOD.


  METHOD get_shipment_stop.

    LOOP AT is_stops-watching ASSIGNING FIELD-SYMBOL(<ls_watching>)
      WHERE vbeln       = is_vbfa-vbelv
        AND stopid(10)  = is_vbfa-vbeln.
      rv_stop   = <ls_watching>-stopid.

      IF iv_arrival = abap_false.
        EXIT.
      ENDIF.
    ENDLOOP.

  ENDMETHOD.


  METHOD is_pod_relevant.

    CLEAR: rv_result.

    IF is_stops-locid   = is_lips-werks AND
       is_stops-loctype = zif_gtt_mia_ef_constants=>cs_loc_types-plant.

      READ TABLE is_ship-ee_rel ASSIGNING FIELD-SYMBOL(<ls_ee_rel>)
        WITH TABLE KEY appobjid = zcl_gtt_mia_dl_tools=>get_tracking_id_dl_item(
                                      ir_lips = REF #( is_lips ) ).

      rv_result = boolc( sy-subrc = 0 AND
                         <ls_ee_rel>-z_pdstk = abap_true ).
    ENDIF.

  ENDMETHOD.


  METHOD prepare_idoc_data.

    "" fill DLV Item
    ""   control data
    ""     YN_DLV_NO
    ""     YN_DLV_ITEM_NO
    ""     ACTUAL_BUSINESS_TIMEZONE
    ""     ACTUAL_BUSINESS_DATETIME
    ""   planned events
    ""     PUTAWAY
    ""     PACKING
    ""     GOODS_RECEIPT
    ""     DEPARTURE
    ""     ARRIV_DEST
    ""     POD
    DATA: ls_idoc_data    TYPE zif_gtt_mia_ctp_tor_types=>ts_idoc_data.

    DATA(lr_ship)   = io_ship_data->get_data( ).
    DATA(lr_stops)  = io_ship_data->get_stops( ).

    FIELD-SYMBOLS: <ls_ship>  TYPE zcl_gtt_mia_ctp_shipment_data=>ts_shipment_merge,
                   <lt_stops> TYPE zcl_gtt_mia_ctp_shipment_data=>tt_stops_srt.

    ASSIGN lr_ship->*  TO <ls_ship>.
    ASSIGN lr_stops->* TO <lt_stops>.

    LOOP AT mt_aotype ASSIGNING FIELD-SYMBOL(<ls_aotype>).
      CLEAR: ls_idoc_data.

      ls_idoc_data-appsys   = mv_appsys.

      fill_idoc_trxserv(
        EXPORTING
          is_aotype    = <ls_aotype>
        CHANGING
          cs_idoc_data = ls_idoc_data ).

      LOOP AT <ls_ship>-likp ASSIGNING FIELD-SYMBOL(<ls_likp>).
        READ TABLE <lt_stops> ASSIGNING FIELD-SYMBOL(<ls_stops>)
          WITH TABLE KEY tknum = <ls_likp>-tknum.

        IF sy-subrc = 0.
          LOOP AT <ls_ship>-likp\\lips[ <ls_likp> ] ASSIGNING FIELD-SYMBOL(<ls_lips>).
            fill_idoc_appobj_ctabs(
              EXPORTING
                is_aotype    = <ls_aotype>
                is_lips      = <ls_lips>
              CHANGING
                cs_idoc_data = ls_idoc_data ).

            fill_idoc_control_data(
              EXPORTING
                is_aotype    = <ls_aotype>
                is_ship      = <ls_ship>
                is_likp      = <ls_likp>
                is_lips      = <ls_lips>
                is_stops     = <ls_stops>
              CHANGING
                cs_idoc_data = ls_idoc_data ).

            fill_idoc_exp_event(
              EXPORTING
                is_aotype    = <ls_aotype>
                is_ship      = <ls_ship>
                is_likp      = <ls_likp>
                is_lips      = <ls_lips>
                is_stops     = <ls_stops>
              CHANGING
                cs_idoc_data = ls_idoc_data ).

            fill_idoc_tracking_id(
              EXPORTING
                is_aotype    = <ls_aotype>
                is_ship      = <ls_ship>
                is_likp      = <ls_likp>
                is_lips      = <ls_lips>
              CHANGING
                cs_idoc_data = ls_idoc_data ).
          ENDLOOP.
        ELSE.
          MESSAGE e005(zgtt_mia) WITH |{ <ls_likp>-tknum }| 'STOPS'
            INTO DATA(lv_dummy).
          zcl_gtt_mia_tools=>throw_exception( ).
        ENDIF.
      ENDLOOP.

      IF ls_idoc_data-appobj_ctabs[] IS NOT INITIAL AND
         ls_idoc_data-control[] IS NOT INITIAL AND
         ls_idoc_data-tracking_id[] IS NOT INITIAL.
        APPEND ls_idoc_data TO mt_idoc_data.
      ENDIF.
    ENDLOOP.

  ENDMETHOD.
ENDCLASS.
",4621,False,979.5261156467818,median
"[[features.external-config]]
== Externalized Configuration
Spring Boot lets you externalize your configuration so that you can work with the same application code in different environments.
You can use a variety of external configuration sources, include Java properties files, YAML files, environment variables, and command-line arguments.

Property values can be injected directly into your beans by using the `@Value` annotation, accessed through Spring's `Environment` abstraction, or be <<features#features.external-config.typesafe-configuration-properties,bound to structured objects>> through `@ConfigurationProperties`.

Spring Boot uses a very particular `PropertySource` order that is designed to allow sensible overriding of values.
Properties are considered in the following order (with values from lower items overriding earlier ones):

. Default properties (specified by setting `SpringApplication.setDefaultProperties`).
. {spring-framework-api}/context/annotation/PropertySource.html[`@PropertySource`] annotations on your `@Configuration` classes.
  Please note that such property sources are not added to the `Environment` until the application context is being refreshed.
  This is too late to configure certain properties such as `+logging.*+` and `+spring.main.*+` which are read before refresh begins.
. Config data (such as `application.properties` files).
. A `RandomValuePropertySource` that has properties only in `+random.*+`.
. OS environment variables.
. Java System properties (`System.getProperties()`).
. JNDI attributes from `java:comp/env`.
. `ServletContext` init parameters.
. `ServletConfig` init parameters.
. Properties from `SPRING_APPLICATION_JSON` (inline JSON embedded in an environment variable or system property).
. Command line arguments.
. `properties` attribute on your tests.
  Available on {spring-boot-test-module-api}/context/SpringBootTest.html[`@SpringBootTest`] and the <<features#features.testing.spring-boot-applications.autoconfigured-tests,test annotations for testing a particular slice of your application>>.
. {spring-framework-api}/test/context/TestPropertySource.html[`@TestPropertySource`] annotations on your tests.
. <<using#using.devtools.globalsettings,Devtools global settings properties>> in the `$HOME/.config/spring-boot` directory when devtools is active.

Config data files are considered in the following order:

. <<features#features.external-config.files,Application properties>> packaged inside your jar (`application.properties` and YAML variants).
. <<features#features.external-config.files.profile-specific,Profile-specific application properties>> packaged inside your jar (`application-\\{profile}.properties` and YAML variants).
. <<features#features.external-config.files,Application properties>> outside of your packaged jar (`application.properties` and YAML variants).
. <<features#features.external-config.files.profile-specific,Profile-specific application properties>> outside of your packaged jar (`application-\\{profile}.properties` and YAML variants).

NOTE: It is recommended to stick with one format for your entire application.
If you have configuration files with both `.properties` and `.yml` format in the same location, `.properties` takes precedence.

To provide a concrete example, suppose you develop a `@Component` that uses a `name` property, as shown in the following example:

include::code:MyBean[]

On your application classpath (for example, inside your jar) you can have an `application.properties` file that provides a sensible default property value for `name`.
When running in a new environment, an `application.properties` file can be provided outside of your jar that overrides the `name`.
For one-off testing, you can launch with a specific command line switch (for example, `java -jar app.jar --name=""Spring""`).

TIP: The `env` and `configprops` endpoints can be useful in determining why a property has a particular value.
You can use these two endpoints to diagnose unexpected property values.
See the ""<<actuator#actuator.endpoints, Production ready features>>"" section for details.



[[features.external-config.command-line-args]]
=== Accessing Command Line Properties
By default, `SpringApplication` converts any command line option arguments (that is, arguments starting with `--`, such as `--server.port=9000`) to a `property` and adds them to the Spring `Environment`.
As mentioned previously, command line properties always take precedence over file-based property sources.

If you do not want command line properties to be added to the `Environment`, you can disable them by using `SpringApplication.setAddCommandLineProperties(false)`.



[[features.external-config.application-json]]
=== JSON Application Properties
Environment variables and system properties often have restrictions that mean some property names cannot be used.
To help with this, Spring Boot allows you to encode a block of properties into a single JSON structure.

When your application starts, any `spring.application.json` or `SPRING_APPLICATION_JSON` properties will be parsed and added to the `Environment`.

For example, the `SPRING_APPLICATION_JSON` property can be supplied on the command line in a UN{asterisk}X shell as an environment variable:

[source,shell,indent=0,subs=""verbatim""]
----
	$ SPRING_APPLICATION_JSON='{""my"":{""name"":""test""}}' java -jar myapp.jar
----

In the preceding example, you end up with `my.name=test` in the Spring `Environment`.

The same JSON can also be provided as a system property:

[source,shell,indent=0,subs=""verbatim""]
----
	$ java -Dspring.application.json='{""my"":{""name"":""test""}}' -jar myapp.jar
----

Or you could supply the JSON by using a command line argument:

[source,shell,indent=0,subs=""verbatim""]
----
	$ java -jar myapp.jar --spring.application.json='{""my"":{""name"":""test""}}'
----

If you are deploying to a classic Application Server, you could also use a JNDI variable named `java:comp/env/spring.application.json`.

NOTE: Although `null` values from the JSON will be added to the resulting property source, the `PropertySourcesPropertyResolver` treats `null` properties as missing values.
This means that the JSON cannot override properties from lower order property sources with a `null` value.



[[features.external-config.files]]
=== External Application Properties [[features.external-config.files]]
Spring Boot will automatically find and load `application.properties` and `application.yaml` files from the following locations when your application starts:

. From the classpath
.. The classpath root
.. The classpath `/config` package
. From the current directory
.. The current directory
.. The `/config` subdirectory in the current directory
.. Immediate child directories of the `/config` subdirectory

The list is ordered by precedence (with values from lower items overriding earlier ones).
Documents from the loaded files are added as `PropertySources` to the Spring `Environment`.

If you do not like `application` as the configuration file name, you can switch to another file name by specifying a configprop:spring.config.name[] environment property.
For example, to look for `myproject.properties` and `myproject.yaml` files you can run your application as follows:

[source,shell,indent=0,subs=""verbatim""]
----
	$ java -jar myproject.jar --spring.config.name=myproject
----

You can also refer to an explicit location by using the configprop:spring.config.location[] environment property.
This property accepts a comma-separated list of one or more locations to check.

The following example shows how to specify two distinct files:

[source,shell,indent=0,subs=""verbatim""]
----
	$ java -jar myproject.jar --spring.config.location=\\
		optional:classpath:/default.properties,\\
		optional:classpath:/override.properties
----

TIP: Use the prefix `optional:` if the <<features#features.external-config.files.optional-prefix,locations are optional>> and you do not mind if they do not exist.

WARNING: `spring.config.name`, `spring.config.location`, and `spring.config.additional-location` are used very early to determine which files have to be loaded.
They must be defined as an environment property (typically an OS environment variable, a system property, or a command-line argument).

If `spring.config.location` contains directories (as opposed to files), they should end in `/`.
At runtime they will be appended with the names generated from `spring.config.name` before being loaded.
Files specified in `spring.config.location` are imported directly.

NOTE: Both directory and file location values are also expanded to check for <<features#features.external-config.files.profile-specific,profile-specific files>>.
For example, if you have a `spring.config.location` of `classpath:myconfig.properties`, you will also find appropriate `classpath:myconfig-<profile>.properties` files are loaded.

In most situations, each configprop:spring.config.location[] item you add will reference a single file or directory.
Locations are processed in the order that they are defined and later ones can override the values of earlier ones.

[[features.external-config.files.location-groups]]
If you have a complex location setup, and you use profile-specific configuration files, you may need to provide further hints so that Spring Boot knows how they should be grouped.
A location group is a collection of locations that are all considered at the same level.
For example, you might want to group all classpath locations, then all external locations.
Items within a location group should be separated with `;`.
See the example in the ""`<<features#features.external-config.files.profile-specific>>`"" section for more details.

Locations configured by using `spring.config.location` replace the default locations.
For example, if `spring.config.location` is configured with the value `optional:classpath:/custom-config/,optional:file:./custom-config/`, the complete set of locations considered is:

. `optional:classpath:custom-config/`
. `optional:file:./custom-config/`

If you prefer to add additional locations, rather than replacing them, you can use `spring.config.additional-location`.
Properties loaded from additional locations can override those in the default locations.
For example, if `spring.config.additional-location` is configured with the value `optional:classpath:/custom-config/,optional:file:./custom-config/`, the complete set of locations considered is:

. `optional:classpath:/;optional:classpath:/config/`
. `optional:file:./;optional:file:./config/;optional:file:./config/*/`
. `optional:classpath:custom-config/`
. `optional:file:./custom-config/`

This search ordering lets you specify default values in one configuration file and then selectively override those values in another.
You can provide default values for your application in `application.properties` (or whatever other basename you choose with `spring.config.name`) in one of the default locations.
These default values can then be overridden at runtime with a different file located in one of the custom locations.

NOTE: If you use environment variables rather than system properties, most operating systems disallow period-separated key names, but you can use underscores instead (for example, configprop:spring.config.name[format=envvar] instead of configprop:spring.config.name[]).
See <<features#features.external-config.typesafe-configuration-properties.relaxed-binding.environment-variables>> for details.

NOTE: If your application runs in a servlet container or application server, then JNDI properties (in `java:comp/env`) or servlet context initialization parameters can be used instead of, or as well as, environment variables or system properties.



[[features.external-config.files.optional-prefix]]
==== Optional Locations
By default, when a specified config data location does not exist, Spring Boot will throw a `ConfigDataLocationNotFoundException` and your application will not start.

If you want to specify a location, but you do not mind if it does not always exist, you can use the `optional:` prefix.
You can use this prefix with the `spring.config.location` and `spring.config.additional-location` properties, as well as with <<features#features.external-config.files.importing, `spring.config.import`>> declarations.

For example, a `spring.config.import` value of `optional:file:./myconfig.properties` allows your application to start, even if the `myconfig.properties` file is missing.

If you want to ignore all `ConfigDataLocationNotFoundExceptions` and always continue to start your application, you can use the `spring.config.on-not-found` property.
Set the value to `ignore` using `SpringApplication.setDefaultProperties(...)` or with a system/environment variable.



[[features.external-config.files.wildcard-locations]]
==== Wildcard Locations
If a config file location includes the `{asterisk}` character for the last path segment, it is considered a wildcard location.
Wildcards are expanded when the config is loaded so that immediate subdirectories are also checked.
Wildcard locations are particularly useful in an environment such as Kubernetes when there are multiple sources of config properties.

For example, if you have some Redis configuration and some MySQL configuration, you might want to keep those two pieces of configuration separate, while requiring that both those are present in an `application.properties` file.
This might result in two separate `application.properties` files mounted at different locations such as `/config/redis/application.properties` and `/config/mysql/application.properties`.
In such a case, having a wildcard location of `config/*/`, will result in both files being processed.

By default, Spring Boot includes `config/*/` in the default search locations.
It means that all subdirectories of the `/config` directory outside of your jar will be searched.

You can use wildcard locations yourself with the `spring.config.location` and `spring.config.additional-location` properties.

NOTE: A wildcard location must contain only one `{asterisk}` and end with `{asterisk}/` for search locations that are directories or `*/<filename>` for search locations that are files.
Locations with wildcards are sorted alphabetically based on the absolute path of the file names.

TIP: Wildcard locations only work with external directories.
You cannot use a wildcard in a `classpath:` location.



[[features.external-config.files.profile-specific]]
==== Profile Specific Files
As well as `application` property files, Spring Boot will also attempt to load profile-specific files using the naming convention `application-\\{profile}`.
For example, if your application activates a profile named `prod` and uses YAML files, then both `application.yml` and `application-prod.yml` will be considered.

Profile-specific properties are loaded from the same locations as standard `application.properties`, with profile-specific files always overriding the non-specific ones.
If several profiles are specified, a last-wins strategy applies.
For example, if profiles `prod,live` are specified by the configprop:spring.profiles.active[] property, values in `application-prod.properties` can be overridden by those in `application-live.properties`.

[NOTE]
====
The last-wins strategy applies at the <<features#features.external-config.files.location-groups,location group>> level.
A configprop:spring.config.location[] of `classpath:/cfg/,classpath:/ext/` will not have the same override rules as `classpath:/cfg/;classpath:/ext/`.

For example, continuing our `prod,live` example above, we might have the following files:

----
/cfg
  application-live.properties
/ext
  application-live.properties
  application-prod.properties
----

When we have a configprop:spring.config.location[] of `classpath:/cfg/,classpath:/ext/` we process all `/cfg` files before all `/ext` files:

. `/cfg/application-live.properties`
. `/ext/application-prod.properties`
. `/ext/application-live.properties`


When we have `classpath:/cfg/;classpath:/ext/` instead (with a `;` delimiter) we process `/cfg` and `/ext` at the same level:

. `/ext/application-prod.properties`
. `/cfg/application-live.properties`
. `/ext/application-live.properties`
====

The `Environment` has a set of default profiles (by default, `[default]`) that are used if no active profiles are set.
In other words, if no profiles are explicitly activated, then properties from `application-default` are considered.

NOTE: Properties files are only ever loaded once.
If you have already directly <<features#features.external-config.files.importing,imported>> a profile specific property files then it will not be imported a second time.



[[features.external-config.files.importing]]
==== Importing Additional Data
Application properties may import further config data from other locations using the `spring.config.import` property.
Imports are processed as they are discovered, and are treated as additional documents inserted immediately below the one that declares the import.

For example, you might have the following in your classpath `application.properties` file:

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	spring:
	  application:
	    name: ""myapp""
	  config:
	    import: ""optional:file:./dev.properties""
----

This will trigger the import of a `dev.properties` file in current directory (if such a file exists).
Values from the imported `dev.properties` will take precedence over the file that triggered the import.
In the above example, the `dev.properties` could redefine `spring.application.name` to a different value.

An import will only be imported once no matter how many times it is declared.
The order an import is defined inside a single document within the properties/yaml file does not matter.
For instance, the two examples below produce the same result:

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	spring:
	  config:
	    import: ""my.properties""
	my:
	  property: ""value""
----

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	my:
	  property: ""value""
	spring:
	  config:
	    import: ""my.properties""
----

In both of the above examples, the values from the `my.properties` file will take precedence over the file that triggered its import.

Several locations can be specified under a single `spring.config.import` key.
Locations will be processed in the order that they are defined, with later imports taking precedence.

NOTE: When appropriate, <<features#features.external-config.files.profile-specific, Profile-specific variants>> are also considered for import.
The example above would import both `my.properties` as well as any `my-<profile>.properties` variants.

[TIP]
====
Spring Boot includes pluggable API that allows various different location addresses to be supported.
By default you can import Java Properties, YAML and ""`<<features#features.external-config.files.configtree, configuration trees>>`"".

Third-party jars can offer support for additional technologies (there is no requirement for files to be local).
For example, you can imagine config data being from external stores such as Consul, Apache ZooKeeper or Netflix Archaius.

If you want to support your own locations, see the `ConfigDataLocationResolver` and `ConfigDataLoader` classes in the `org.springframework.boot.context.config` package.
====



[[features.external-config.files.importing-extensionless]]
==== Importing Extensionless Files
Some cloud platforms cannot add a file extension to volume mounted files.
To import these extensionless files, you need to give Spring Boot a hint so that it knows how to load them.
You can do this by putting an extension hint in square brackets.

For example, suppose you have a `/etc/config/myconfig` file that you wish to import as yaml.
You can import it from your `application.properties` using the following:

[source,yaml,indent=0,subs=""verbatim"",configprops,configblocks]
----
	spring:
	  config:
	    import: ""file:/etc/config/myconfig[.yaml]""
----



[[features.external-config.files.configtree]]
==== Using Configuration Trees
When running applications on a cloud platform (such as Kubernetes) you often need to read config values that the platform supplies.
It is not uncommon to use environment variables for such purposes, but this can have drawbacks, especially if the value is supposed to be kept secret.

As an alternative to environment variables, many cloud platforms now allow you to map configuration into mounted data volumes.
For example, Kubernetes can volume mount both https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/#populate-a-volume-with-data-stored-in-a-configmap[`ConfigMaps`] and https://kubernetes.io/docs/concepts/configuration/secret/#using-secrets-as-files-from-a-pod[`Secrets`].

There are two common volume mount patterns that can be used:

. A single file contains a complete set of properties (usually written as YAML).
. Multiple files are written to a directory tree, with the filename becoming the '`key`' and the contents becoming the '`value`'.

For the first case, you can import the YAML or Properties file directly using `spring.config.import` as described <<features#features.external-config.files.importing,above>>.
For the second case, you need to use the `configtree:` prefix so that Spring Boot knows it needs to expose all the files as properties.

As an example, let's imagine that Kubernetes has mounted the following volume:

[indent=0]
----
	etc/
	  config/
	    myapp/
	      username
	      password
----

The contents of the `username` file would be a config value, and the contents of `password` would be a secret.

To import these properties, you can add the following to your `application.properties` or `application.yaml` file:

[source,yaml,indent=0,subs=""verbatim"",configprops,configblocks]
----
	spring:
	  config:
	    import: ""optional:configtree:/etc/config/""
----

You can then access or inject `myapp.username` and `myapp.password` properties from the `Environment` in the usual way.

TIP: The folders under the config tree form the property name.
In the above example, to access the properties as `username` and `password`, you can set `spring.config.import` to `optional:configtree:/etc/config/myapp`.

NOTE: Filenames with dot notation are also correctly mapped.
For example, in the above example, a file named `myapp.username` in `/etc/config` would result in a `myapp.username` property in the `Environment`.

TIP: Configuration tree values can be bound to both string `String` and `byte[]` types depending on the contents expected.

If you have multiple config trees to import from the same parent folder you can use a wildcard shortcut.
Any `configtree:` location that ends with `/*/` will import all immediate children as config trees.

For example, given the following volume:

[indent=0]
----
	etc/
	  config/
	    dbconfig/
	      db/
	        username
	        password
	    mqconfig/
	      mq/
	        username
	        password
----

You can use `configtree:/etc/config/*/` as the import location:

[source,yaml,indent=0,subs=""verbatim"",configprops,configblocks]
----
	spring:
	  config:
	    import: ""optional:configtree:/etc/config/*/""
----

This will add `db.username`, `db.password`, `mq.username` and `mq.password` properties.

NOTE: Directories loaded using a wildcard are sorted alphabetically.
If you need a different order, then you should list each location as a separate import


Configuration trees can also be used for Docker secrets.
When a Docker swarm service is granted access to a secret, the secret gets mounted into the container.
For example, if a secret named `db.password` is mounted at location `/run/secrets/`, you can make `db.password` available to the Spring environment using the following:

[source,yaml,indent=0,subs=""verbatim"",configprops,configblocks]
----
	spring:
	  config:
	    import: ""optional:configtree:/run/secrets/""
----



[[features.external-config.files.property-placeholders]]
==== Property Placeholders
The values in `application.properties` and `application.yml` are filtered through the existing `Environment` when they are used, so you can refer back to previously defined values (for example, from System properties or environment variables).
The standard `$\\{name}` property-placeholder syntax can be used anywhere within a value.
Property placeholders can also specify a default value using a `:` to separate the default value from the property name, for example `${name:default}`.

The use of placeholders with and without defaults is shown in the following example:

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	app:
	  name: ""MyApp""
	  description: ""${app.name} is a Spring Boot application written by ${username:Unknown}""
----

Assuming that the `username` property has not been set elsewhere, `app.description` will have the value `MyApp is a Spring Boot application written by Unknown`.

TIP: You can also use this technique to create ""`short`"" variants of existing Spring Boot properties.
See the _<<howto#howto.properties-and-configuration.short-command-line-arguments>>_ how-to for details.



[[features.external-config.files.multi-document]]
==== Working with Multi-Document Files
Spring Boot allows you to split a single physical file into multiple logical documents which are each added independently.
Documents are processed in order, from top to bottom.
Later documents can override the properties defined in earlier ones.

For `application.yml` files, the standard YAML multi-document syntax is used.
Three consecutive hyphens represent the end of one document, and the start of the next.

For example, the following file has two logical documents:

[source,yaml,indent=0,subs=""verbatim""]
----
	spring:
	  application:
	    name: ""MyApp""
	---
	spring:
	  application:
	    name: ""MyCloudApp""
	  config:
	    activate:
	      on-cloud-platform: ""kubernetes""
----

For `application.properties` files a special `#---` comment is used to mark the document splits:

[source,properties,indent=0,subs=""verbatim""]
----
	spring.application.name=MyApp
	#---
	spring.application.name=MyCloudApp
	spring.config.activate.on-cloud-platform=kubernetes
----

NOTE: Property file separators must not have any leading whitespace and must have exactly three hyphen characters.
The lines immediately before and after the separator must not be comments.

TIP: Multi-document property files are often used in conjunction with activation properties such as `spring.config.activate.on-profile`.
See the <<features#features.external-config.files.activation-properties, next section>> for details.

WARNING: Multi-document property files cannot be loaded by using the `@PropertySource` or `@TestPropertySource` annotations.



[[features.external-config.files.activation-properties]]
==== Activation Properties
It is sometimes useful to only activate a given set of properties when certain conditions are met.
For example, you might have properties that are only relevant when a specific profile is active.

You can conditionally activate a properties document using `spring.config.activate.*`.

The following activation properties are available:

.activation properties
[cols=""1,4""]
|===
| Property | Note

| `on-profile`
| A profile expression that must match for the document to be active.

| `on-cloud-platform`
| The `CloudPlatform` that must be detected for the document to be active.
|===

For example, the following specifies that the second document is only active when running on Kubernetes, and only when either the ""`prod`"" or ""`staging`"" profiles are active:

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	myprop:
	  ""always-set""
	---
	spring:
	  config:
	    activate:
	      on-cloud-platform: ""kubernetes""
	      on-profile: ""prod | staging""
	myotherprop: ""sometimes-set""
----



[[features.external-config.encrypting]]
=== Encrypting Properties
Spring Boot does not provide any built in support for encrypting property values, however, it does provide the hook points necessary to modify values contained in the Spring `Environment`.
The `EnvironmentPostProcessor` interface allows you to manipulate the `Environment` before the application starts.
See <<howto#howto.application.customize-the-environment-or-application-context>> for details.

If you need a secure way to store credentials and passwords, the https://cloud.spring.io/spring-cloud-vault/[Spring Cloud Vault] project provides support for storing externalized configuration in https://www.vaultproject.io/[HashiCorp Vault].



[[features.external-config.yaml]]
=== Working with YAML
https://yaml.org[YAML] is a superset of JSON and, as such, is a convenient format for specifying hierarchical configuration data.
The `SpringApplication` class automatically supports YAML as an alternative to properties whenever you have the https://bitbucket.org/asomov/snakeyaml[SnakeYAML] library on your classpath.

NOTE: If you use ""`Starters`"", SnakeYAML is automatically provided by `spring-boot-starter`.



[[features.external-config.yaml.mapping-to-properties]]
==== Mapping YAML to Properties
YAML documents need to be converted from their hierarchical format to a flat structure that can be used with the Spring `Environment`.
For example, consider the following YAML document:

[source,yaml,indent=0,subs=""verbatim""]
----
	environments:
	  dev:
	    url: ""https://dev.example.com""
	    name: ""Developer Setup""
	  prod:
	    url: ""https://another.example.com""
	    name: ""My Cool App""
----

In order to access these properties from the `Environment`, they would be flattened as follows:

[source,properties,indent=0,subs=""verbatim""]
----
	environments.dev.url=https://dev.example.com
	environments.dev.name=Developer Setup
	environments.prod.url=https://another.example.com
	environments.prod.name=My Cool App
----

Likewise, YAML lists also need to be flattened.
They are represented as property keys with `[index]` dereferencers.
For example, consider the following YAML:

[source,yaml,indent=0,subs=""verbatim""]
----
	 my:
	  servers:
	  - ""dev.example.com""
	  - ""another.example.com""
----

The preceding example would be transformed into these properties:

[source,properties,indent=0,subs=""verbatim""]
----
	my.servers[0]=dev.example.com
	my.servers[1]=another.example.com
----

TIP: Properties that use the `[index]` notation can be bound to Java `List` or `Set` objects using Spring Boot's `Binder` class.
For more details see the ""`<<features#features.external-config.typesafe-configuration-properties>>`"" section below.

WARNING: YAML files cannot be loaded by using the `@PropertySource` or `@TestPropertySource` annotations.
So, in the case that you need to load values that way, you need to use a properties file.



[[features.external-config.yaml.directly-loading]]
[[features.external-config.yaml.directly-loading]]
==== Directly Loading YAML
Spring Framework provides two convenient classes that can be used to load YAML documents.
The `YamlPropertiesFactoryBean` loads YAML as `Properties` and the `YamlMapFactoryBean` loads YAML as a `Map`.

You can also use the `YamlPropertySourceLoader` class if you want to load YAML as a Spring `PropertySource`.



[[features.external-config.random-values]]
=== Configuring Random Values
The `RandomValuePropertySource` is useful for injecting random values (for example, into secrets or test cases).
It can produce integers, longs, uuids, or strings, as shown in the following example:

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	my:
	  secret: ""${random.value}""
	  number: ""${random.int}""
	  bignumber: ""${random.long}""
	  uuid: ""${random.uuid}""
	  number-less-than-ten: ""${random.int(10)}""
	  number-in-range: ""${random.int[1024,65536]}""
----

The `+random.int*+` syntax is `OPEN value (,max) CLOSE` where the `OPEN,CLOSE` are any character and `value,max` are integers.
If `max` is provided, then `value` is the minimum value and `max` is the maximum value (exclusive).



[[features.external-config.system-environment]]
=== Configuring System Environment Properties
Spring Boot supports setting a prefix for environment properties.
This is useful if the system environment is shared by multiple Spring Boot applications with different configuration requirements.
The prefix for system environment properties can be set directly on `SpringApplication`.

For example, if you set the prefix to `input`, a property such as `remote.timeout` will also be resolved as `input.remote.timeout` in the system environment.



[[features.external-config.typesafe-configuration-properties]]
=== Type-safe Configuration Properties
Using the `@Value(""$\\{property}"")` annotation to inject configuration properties can sometimes be cumbersome, especially if you are working with multiple properties or your data is hierarchical in nature.
Spring Boot provides an alternative method of working with properties that lets strongly typed beans govern and validate the configuration of your application.

TIP: See also the <<features#features.external-config.typesafe-configuration-properties.vs-value-annotation,differences between `@Value` and type-safe configuration properties>>.



[[features.external-config.typesafe-configuration-properties.java-bean-binding]]
==== JavaBean properties binding
It is possible to bind a bean declaring standard JavaBean properties as shown in the following example:

include::code:MyProperties[]

The preceding POJO defines the following properties:

* `my.service.enabled`, with a value of `false` by default.
* `my.service.remote-address`, with a type that can be coerced from `String`.
* `my.service.security.username`, with a nested ""security"" object whose name is determined by the name of the property.
  In particular, the type is not used at all there and could have been `SecurityProperties`.
* `my.service.security.password`.
* `my.service.security.roles`, with a collection of `String` that defaults to `USER`.

NOTE: The properties that map to `@ConfigurationProperties` classes available in Spring Boot, which are configured through properties files, YAML files, environment variables, and other mechanisms, are public API but the accessors (getters/setters) of the class itself are not meant to be used directly.

[NOTE]
====
Such arrangement relies on a default empty constructor and getters and setters are usually mandatory, since binding is through standard Java Beans property descriptors, just like in Spring MVC.
A setter may be omitted in the following cases:

* Maps, as long as they are initialized, need a getter but not necessarily a setter, since they can be mutated by the binder.
* Collections and arrays can be accessed either through an index (typically with YAML) or by using a single comma-separated value (properties).
  In the latter case, a setter is mandatory.
  We recommend to always add a setter for such types.
  If you initialize a collection, make sure it is not immutable (as in the preceding example).
* If nested POJO properties are initialized (like the `Security` field in the preceding example), a setter is not required.
  If you want the binder to create the instance on the fly by using its default constructor, you need a setter.

Some people use Project Lombok to add getters and setters automatically.
Make sure that Lombok does not generate any particular constructor for such a type, as it is used automatically by the container to instantiate the object.

Finally, only standard Java Bean properties are considered and binding on static properties is not supported.
====



[[features.external-config.typesafe-configuration-properties.constructor-binding]]
==== Constructor binding
The example in the previous section can be rewritten in an immutable fashion as shown in the following example:

include::code:MyProperties[]

In this setup, the presence of a single parameterized constructor implies that constructor binding should be used.
This means that the binder will find a constructor with the parameters that you wish to have bound.
If your class has multiple constructors, the `@ConstructorBinding` annotation can be used to specify which constructor to use for constructor binding.
To opt out of constructor binding for a class with a single parameterized constructor, the constructor must be annotated with `@Autowired`.
If you are using Java 16 or later, constructor binding can be used with records.
Unless your record has multiple constructors, there is no need to use `@ConstructorBinding`.

Nested members of a constructor bound class (such as `Security` in the example above) will also be bound through their constructor.

Default values can be specified using `@DefaultValue` on constructor parameters and record components.
The conversion service will be applied to coerce the annotation's `String` value to the target type of a missing property.

Referring to the previous example, if no properties are bound to `Security`, the `MyProperties` instance will contain a `null` value for `security`.

If you wish you return a non-null instance of `Security` even when no properties are bound to it, you can use an empty `@DefaultValue` annotation to do so:

include::code:nonnull/MyProperties[tag=*]


NOTE: To use constructor binding the class must be enabled using `@EnableConfigurationProperties` or configuration property scanning.
You cannot use constructor binding with beans that are created by the regular Spring mechanisms (for example `@Component` beans, beans created by using `@Bean` methods or beans loaded by using `@Import`)

NOTE: The use of `java.util.Optional` with `@ConfigurationProperties` is not recommended as it is primarily intended for use as a return type.
As such, it is not well-suited to configuration property injection.
For consistency with properties of other types, if you do declare an `Optional` property and it has no value, `null` rather than an empty `Optional` will be bound.



[[features.external-config.typesafe-configuration-properties.enabling-annotated-types]]
==== Enabling @ConfigurationProperties-annotated types
Spring Boot provides infrastructure to bind `@ConfigurationProperties` types and register them as beans.
You can either enable configuration properties on a class-by-class basis or enable configuration property scanning that works in a similar manner to component scanning.

Sometimes, classes annotated with `@ConfigurationProperties` might not be suitable for scanning, for example, if you're developing your own auto-configuration or you want to enable them conditionally.
In these cases, specify the list of types to process using the `@EnableConfigurationProperties` annotation.
This can be done on any `@Configuration` class, as shown in the following example:

include::code:MyConfiguration[]

To use configuration property scanning, add the `@ConfigurationPropertiesScan` annotation to your application.
Typically, it is added to the main application class that is annotated with `@SpringBootApplication` but it can be added to any `@Configuration` class.
By default, scanning will occur from the package of the class that declares the annotation.
If you want to define specific packages to scan, you can do so as shown in the following example:

include::code:MyApplication[]

[NOTE]
====
When the `@ConfigurationProperties` bean is registered using configuration property scanning or through `@EnableConfigurationProperties`, the bean has a conventional name: `<prefix>-<fqn>`, where `<prefix>` is the environment key prefix specified in the `@ConfigurationProperties` annotation and `<fqn>` is the fully qualified name of the bean.
If the annotation does not provide any prefix, only the fully qualified name of the bean is used.

The bean name in the example above is `com.example.app-com.example.app.SomeProperties`.
====

We recommend that `@ConfigurationProperties` only deal with the environment and, in particular, does not inject other beans from the context.
For corner cases, setter injection can be used or any of the `*Aware` interfaces provided by the framework (such as `EnvironmentAware` if you need access to the `Environment`).
If you still want to inject other beans using the constructor, the configuration properties bean must be annotated with `@Component` and use JavaBean-based property binding.



[[features.external-config.typesafe-configuration-properties.using-annotated-types]]
==== Using @ConfigurationProperties-annotated types
This style of configuration works particularly well with the `SpringApplication` external YAML configuration, as shown in the following example:

[source,yaml,indent=0,subs=""verbatim""]
----
	my:
	  service:
	    remote-address: 192.168.1.1
	    security:
	      username: ""admin""
	      roles:
	      - ""USER""
	      - ""ADMIN""
----

To work with `@ConfigurationProperties` beans, you can inject them in the same way as any other bean, as shown in the following example:

include::code:MyService[]

TIP: Using `@ConfigurationProperties` also lets you generate metadata files that can be used by IDEs to offer auto-completion for your own keys.
See the <<configuration-metadata#appendix.configuration-metadata,appendix>> for details.



[[features.external-config.typesafe-configuration-properties.third-party-configuration]]
==== Third-party Configuration
As well as using `@ConfigurationProperties` to annotate a class, you can also use it on public `@Bean` methods.
Doing so can be particularly useful when you want to bind properties to third-party components that are outside of your control.

To configure a bean from the `Environment` properties, add `@ConfigurationProperties` to its bean registration, as shown in the following example:

include::code:ThirdPartyConfiguration[]

Any JavaBean property defined with the `another` prefix is mapped onto that `AnotherComponent` bean in manner similar to the preceding `SomeProperties` example.



[[features.external-config.typesafe-configuration-properties.relaxed-binding]]
==== Relaxed Binding
Spring Boot uses some relaxed rules for binding `Environment` properties to `@ConfigurationProperties` beans, so there does not need to be an exact match between the `Environment` property name and the bean property name.
Common examples where this is useful include dash-separated environment properties (for example, `context-path` binds to `contextPath`), and capitalized environment properties (for example, `PORT` binds to `port`).

As an example, consider the following `@ConfigurationProperties` class:

include::code:MyPersonProperties[]

With the preceding code, the following properties names can all be used:

.relaxed binding
[cols=""1,4""]
|===
| Property | Note

| `my.main-project.person.first-name`
| Kebab case, which is recommended for use in `.properties` and `.yml` files.

| `my.main-project.person.firstName`
| Standard camel case syntax.

| `my.main-project.person.first_name`
| Underscore notation, which is an alternative format for use in `.properties` and `.yml` files.

| `MY_MAINPROJECT_PERSON_FIRSTNAME`
| Upper case format, which is recommended when using system environment variables.
|===

NOTE: The `prefix` value for the annotation _must_ be in kebab case (lowercase and separated by `-`, such as `my.main-project.person`).

.relaxed binding rules per property source
[cols=""2,4,4""]
|===
| Property Source | Simple | List

| Properties Files
| Camel case, kebab case, or underscore notation
| Standard list syntax using `[ ]` or comma-separated values

| YAML Files
| Camel case, kebab case, or underscore notation
| Standard YAML list syntax or comma-separated values

| Environment Variables
| Upper case format with underscore as the delimiter (see <<features#features.external-config.typesafe-configuration-properties.relaxed-binding.environment-variables>>).
| Numeric values surrounded by underscores (see <<features#features.external-config.typesafe-configuration-properties.relaxed-binding.environment-variables>>)

| System properties
| Camel case, kebab case, or underscore notation
| Standard list syntax using `[ ]` or comma-separated values
|===

TIP: We recommend that, when possible, properties are stored in lower-case kebab format, such as `my.person.first-name=Rod`.



[[features.external-config.typesafe-configuration-properties.relaxed-binding.maps]]
===== Binding Maps
When binding to `Map` properties you may need to use a special bracket notation so that the original `key` value is preserved.
If the key is not surrounded by `[]`, any characters that are not alpha-numeric, `-` or `.` are removed.

For example, consider binding the following properties to a `Map<String,String>`:


[source,properties,indent=0,subs=""verbatim"",role=""primary""]
.Properties
----
	my.map.[/key1]=value1
	my.map.[/key2]=value2
	my.map./key3=value3
----

[source,yaml,indent=0,subs=""verbatim"",role=""secondary""]
.Yaml
----
	my:
	  map:
	    ""[/key1]"": ""value1""
	    ""[/key2]"": ""value2""
	    ""/key3"": ""value3""
----

NOTE: For YAML files, the brackets need to be surrounded by quotes for the keys to be parsed properly.

The properties above will bind to a `Map` with `/key1`, `/key2` and `key3` as the keys in the map.
The slash has been removed from `key3` because it was not surrounded by square brackets.

When binding to scalar values, keys with `.` in them do not need to be surrounded by `[]`.
Scalar values include enums and all types in the `java.lang` package except for `Object`.
Binding `a.b=c` to `Map<String, String>` will preserve the `.` in the key and return a Map with the entry `{""a.b""=""c""}`.
For any other types you need to use the bracket notation if your `key` contains a `.`.
For example, binding `a.b=c` to `Map<String, Object>` will return a Map with the entry `{""a""={""b""=""c""}}` whereas `[a.b]=c` will return a Map with the entry `{""a.b""=""c""}`.



[[features.external-config.typesafe-configuration-properties.relaxed-binding.environment-variables]]
===== Binding from Environment Variables
Most operating systems impose strict rules around the names that can be used for environment variables.
For example, Linux shell variables can contain only letters (`a` to `z` or `A` to `Z`), numbers (`0` to `9`) or the underscore character (`_`).
By convention, Unix shell variables will also have their names in UPPERCASE.

Spring Boot's relaxed binding rules are, as much as possible, designed to be compatible with these naming restrictions.

To convert a property name in the canonical-form to an environment variable name you can follow these rules:

* Replace dots (`.`) with underscores (`_`).
* Remove any dashes (`-`).
* Convert to uppercase.

For example, the configuration property `spring.main.log-startup-info` would be an environment variable named `SPRING_MAIN_LOGSTARTUPINFO`.

Environment variables can also be used when binding to object lists.
To bind to a `List`, the element number should be surrounded with underscores in the variable name.

For example, the configuration property `my.service[0].other` would use an environment variable named `MY_SERVICE_0_OTHER`.



[[features.external-config.typesafe-configuration-properties.merging-complex-types]]
==== Merging Complex Types
When lists are configured in more than one place, overriding works by replacing the entire list.

For example, assume a `MyPojo` object with `name` and `description` attributes that are `null` by default.
The following example exposes a list of `MyPojo` objects from `MyProperties`:

include::code:list/MyProperties[]

Consider the following configuration:

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	my:
	  list:
	  - name: ""my name""
	    description: ""my description""
	---
	spring:
	  config:
	    activate:
	      on-profile: ""dev""
	my:
	  list:
	  - name: ""my another name""
----

If the `dev` profile is not active, `MyProperties.list` contains one `MyPojo` entry, as previously defined.
If the `dev` profile is enabled, however, the `list` _still_ contains only one entry (with a name of `my another name` and a description of `null`).
This configuration _does not_ add a second `MyPojo` instance to the list, and it does not merge the items.

When a `List` is specified in multiple profiles, the one with the highest priority (and only that one) is used.
Consider the following example:

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	my:
	  list:
	  - name: ""my name""
	    description: ""my description""
	  - name: ""another name""
	    description: ""another description""
	---
	spring:
	  config:
	    activate:
	      on-profile: ""dev""
	my:
	  list:
	  - name: ""my another name""
----

In the preceding example, if the `dev` profile is active, `MyProperties.list` contains _one_ `MyPojo` entry (with a name of `my another name` and a description of `null`).
For YAML, both comma-separated lists and YAML lists can be used for completely overriding the contents of the list.

For `Map` properties, you can bind with property values drawn from multiple sources.
However, for the same property in multiple sources, the one with the highest priority is used.
The following example exposes a `Map<String, MyPojo>` from `MyProperties`:

include::code:map/MyProperties[]

Consider the following configuration:

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	my:
	  map:
	    key1:
	      name: ""my name 1""
	      description: ""my description 1""
	---
	spring:
	  config:
	    activate:
	      on-profile: ""dev""
	my:
	  map:
	    key1:
	      name: ""dev name 1""
	    key2:
	      name: ""dev name 2""
	      description: ""dev description 2""
----

If the `dev` profile is not active, `MyProperties.map` contains one entry with key `key1` (with a name of `my name 1` and a description of `my description 1`).
If the `dev` profile is enabled, however, `map` contains two entries with keys `key1` (with a name of `dev name 1` and a description of `my description 1`) and `key2` (with a name of `dev name 2` and a description of `dev description 2`).

NOTE: The preceding merging rules apply to properties from all property sources, and not just files.



[[features.external-config.typesafe-configuration-properties.conversion]]
==== Properties Conversion
Spring Boot attempts to coerce the external application properties to the right type when it binds to the `@ConfigurationProperties` beans.
If you need custom type conversion, you can provide a `ConversionService` bean (with a bean named `conversionService`) or custom property editors (through a `CustomEditorConfigurer` bean) or custom `Converters` (with bean definitions annotated as `@ConfigurationPropertiesBinding`).

NOTE: As this bean is requested very early during the application lifecycle, make sure to limit the dependencies that your `ConversionService` is using.
Typically, any dependency that you require may not be fully initialized at creation time.
You may want to rename your custom `ConversionService` if it is not required for configuration keys coercion and only rely on custom converters qualified with `@ConfigurationPropertiesBinding`.



[[features.external-config.typesafe-configuration-properties.conversion.durations]]
===== Converting Durations
Spring Boot has dedicated support for expressing durations.
If you expose a `java.time.Duration` property, the following formats in application properties are available:

* A regular `long` representation (using milliseconds as the default unit unless a `@DurationUnit` has been specified)
* The standard ISO-8601 format {java-api}/java/time/Duration.html#parse-java.lang.CharSequence-[used by `java.time.Duration`]
* A more readable format where the value and the unit are coupled (`10s` means 10 seconds)

Consider the following example:

include::code:javabeanbinding/MyProperties[]

To specify a session timeout of 30 seconds, `30`, `PT30S` and `30s` are all equivalent.
A read timeout of 500ms can be specified in any of the following form: `500`, `PT0.5S` and `500ms`.

You can also use any of the supported units.
These are:

* `ns` for nanoseconds
* `us` for microseconds
* `ms` for milliseconds
* `s` for seconds
* `m` for minutes
* `h` for hours
* `d` for days

The default unit is milliseconds and can be overridden using `@DurationUnit` as illustrated in the sample above.

If you prefer to use constructor binding, the same properties can be exposed, as shown in the following example:

include::code:constructorbinding/MyProperties[]


TIP: If you are upgrading a `Long` property, make sure to define the unit (using `@DurationUnit`) if it is not milliseconds.
Doing so gives a transparent upgrade path while supporting a much richer format.



[[features.external-config.typesafe-configuration-properties.conversion.periods]]
===== Converting periods
In addition to durations, Spring Boot can also work with `java.time.Period` type.
The following formats can be used in application properties:

* An regular `int` representation (using days as the default unit unless a `@PeriodUnit` has been specified)
* The standard ISO-8601 format {java-api}/java/time/Period.html#parse-java.lang.CharSequence-[used by `java.time.Period`]
* A simpler format where the value and the unit pairs are coupled (`1y3d` means 1 year and 3 days)

The following units are supported with the simple format:

* `y` for years
* `m` for months
* `w` for weeks
* `d` for days

NOTE: The `java.time.Period` type never actually stores the number of weeks, it is a shortcut that means ""`7 days`"".



[[features.external-config.typesafe-configuration-properties.conversion.data-sizes]]
===== Converting Data Sizes
Spring Framework has a `DataSize` value type that expresses a size in bytes.
If you expose a `DataSize` property, the following formats in application properties are available:

* A regular `long` representation (using bytes as the default unit unless a `@DataSizeUnit` has been specified)
* A more readable format where the value and the unit are coupled (`10MB` means 10 megabytes)

Consider the following example:

include::code:javabeanbinding/MyProperties[]

To specify a buffer size of 10 megabytes, `10` and `10MB` are equivalent.
A size threshold of 256 bytes can be specified as `256` or `256B`.

You can also use any of the supported units.
These are:

* `B` for bytes
* `KB` for kilobytes
* `MB` for megabytes
* `GB` for gigabytes
* `TB` for terabytes

The default unit is bytes and can be overridden using `@DataSizeUnit` as illustrated in the sample above.

If you prefer to use constructor binding, the same properties can be exposed, as shown in the following example:

include::code:constructorbinding/MyProperties[]

TIP: If you are upgrading a `Long` property, make sure to define the unit (using `@DataSizeUnit`) if it is not bytes.
Doing so gives a transparent upgrade path while supporting a much richer format.



[[features.external-config.typesafe-configuration-properties.validation]]
==== @ConfigurationProperties Validation
Spring Boot attempts to validate `@ConfigurationProperties` classes whenever they are annotated with Spring's `@Validated` annotation.
You can use JSR-303 `javax.validation` constraint annotations directly on your configuration class.
To do so, ensure that a compliant JSR-303 implementation is on your classpath and then add constraint annotations to your fields, as shown in the following example:

include::code:MyProperties[]

TIP: You can also trigger validation by annotating the `@Bean` method that creates the configuration properties with `@Validated`.

To ensure that validation is always triggered for nested properties, even when no properties are found, the associated field must be annotated with `@Valid`.
The following example builds on the preceding `MyProperties` example:

include::code:nested/MyProperties[]

You can also add a custom Spring `Validator` by creating a bean definition called `configurationPropertiesValidator`.
The `@Bean` method should be declared `static`.
The configuration properties validator is created very early in the application's lifecycle, and declaring the `@Bean` method as static lets the bean be created without having to instantiate the `@Configuration` class.
Doing so avoids any problems that may be caused by early instantiation.

TIP: The `spring-boot-actuator` module includes an endpoint that exposes all `@ConfigurationProperties` beans.
Point your web browser to `/actuator/configprops` or use the equivalent JMX endpoint.
See the ""<<actuator#actuator.endpoints, Production ready features>>"" section for details.



[[features.external-config.typesafe-configuration-properties.vs-value-annotation]]
==== @ConfigurationProperties vs. @Value
The `@Value` annotation is a core container feature, and it does not provide the same features as type-safe configuration properties.
The following table summarizes the features that are supported by `@ConfigurationProperties` and `@Value`:

[cols=""4,2,2""]
|===
| Feature |`@ConfigurationProperties` |`@Value`

| <<features#features.external-config.typesafe-configuration-properties.relaxed-binding,Relaxed binding>>
| Yes
| Limited (see <<features#features.external-config.typesafe-configuration-properties.vs-value-annotation.note,note below>>)

| <<configuration-metadata#appendix.configuration-metadata,Meta-data support>>
| Yes
| No

| `SpEL` evaluation
| No
| Yes
|===

[[features.external-config.typesafe-configuration-properties.vs-value-annotation.note]]
NOTE: If you do want to use `@Value`, we recommend that you refer to property names using their canonical form (kebab-case using only lowercase letters).
This will allow Spring Boot to use the same logic as it does when relaxed binding `@ConfigurationProperties`.
For example, `@Value(""{demo.item-price}"")` will pick up `demo.item-price` and `demo.itemPrice` forms from the `application.properties` file, as well as `DEMO_ITEMPRICE` from the system environment.
If you used `@Value(""{demo.itemPrice}"")` instead, `demo.item-price` and `DEMO_ITEMPRICE` would not be considered.

If you define a set of configuration keys for your own components, we recommend you group them in a POJO annotated with `@ConfigurationProperties`.
Doing so will provide you with structured, type-safe object that you can inject into your own beans.

`SpEL` expressions from  <<features#features.external-config.files,application property files>> are not processed at time of parsing these files and populating the environment.
However, it is possible to write a `SpEL` expression in `@Value`.
If the value of a property from an application property file is a `SpEL` expression, it will be evaluated when consumed through `@Value`.
",12429,False,2158.998655617865,median
"= {prodname} Connector for MongoDB

ifndef::cdc-product[]
include::../_attributes.adoc[]
:toc:
:toc-placement: macro
:linkattrs:
:icons: font
:source-highlighter: highlight.js

toc::[]
endif::cdc-product[]

ifdef::cdc-product[]
[IMPORTANT]
====
Technology Preview features are not supported with Red Hat production service-level agreements (SLAs) and might not be functionally complete; therefore, Red Hat does not recommend implementing any Technology Preview features in production environments. This Technology Preview feature provides early access to upcoming product innovations, enabling you to test functionality and provide feedback during the development process.
For more information about support scope, see link:https://access.redhat.com/support/offerings/techpreview/[Technology Preview Features Support Scope^].
====
endif::cdc-product[]

{prodname}'s MongoDB connector tracks a MongoDB replica set or a MongoDB sharded cluster for document changes in databases and collections, recording those changes as events in Kafka topics.
The connector automatically handles the addition or removal of shards in a sharded cluster, changes in membership of each replica set, elections within each replica set, and awaiting the resolution of communications problems.

[[mongodb-overview]]
== Overview

MongoDB's replication mechanism provides redundancy and high availability, and is the preferred way to run MongoDB in production.
MongoDB connector captures the changes in a replica set or sharded cluster.

A MongoDB _replica set_ consists of a set of servers that all have copies of the same data, and replication ensures that all changes made by clients to documents on the replica set's _primary_ are correctly applied to the other replica set's servers, called _secondaries_.
MongoDB replication works by having the primary record the changes in its _oplog_ (or operation log), and then each of the secondaries reads the primary's oplog and applies in order all of the operations to their own documents.
When a new server is added to a replica set, that server first performs an https://docs.mongodb.com/manual/core/replica-set-sync/[initial sync] of all of the databases and collections on the primary, and then reads the primary's oplog to apply all changes that might have been made since it began the initial sync.
This new server becomes a secondary (and able to handle queries) when it catches up to the tail of the primary's oplog.

The MongoDB connector uses this same replication mechanism, though it does not actually become a member of the replica set.
Just like MongoDB secondaries, however, the connector always reads the oplog of the replica set's primary.
And, when the connector sees a replica set for the first time, it looks at the oplog to get the last recorded transaction and then performs an _intial sync_ of the primary's databases and collections.
When all the data is copied, the connector then starts reading the oplog from the position it read earlier. Operations in the MongoDB oplog are https://docs.mongodb.com/manual/core/replica-set-oplog/[idempotent], so no matter how many times the operations are applied, they result in the same end state.

As the MongoDB connector processes the oplog, it periodically records the position in the oplog where the event originated.
When the MongoDB connector stops, it records the last oplog position that it processed, so that upon restart it simply begins reading the oplog from that position.
In other words, the connector can be stopped, upgraded or maintained, and restarted some time later, and it will pick up exactly where it left off without losing a single event.
Of course, MongoDB's oplogs are usually capped at a maximum size, which means that the connector should not be stopped for too long, or else some of the operations in the oplog might be purged before the connector has a chance to read them.
In this case, upon restart the connector will detect the missing oplog operations, perform an initial sync, and then proceed to tail the oplog.

The MongoDB connector is also quite tolerant of changes in membership and leadership of the replica sets, of additions or removals of shards within a sharded cluster, and network problems that might cause communication failures.
The connector always uses the replica set's primary node to tail the oplog, so when the replica set undergoes an election and a different node becomes primary, the connector will immediately stop tailing the oplog, connect to the new primary, and start tailing the oplog using the new primary node.
Likewise, if connector experiences any problems communicating with the replica set primary, it will try to reconnect (using exponential backoff so as to not overwhelm the network or replica set) and continue tailing the oplog from where it last left off.
In this way the connector is able to dynamically adjust to changes in replica set membership and to automatically handle communication failures.

.Additional resources

* https://docs.mongodb.com/manual/replication/[Replication mechanism]
* link:https://docs.mongodb.com/manual/tutorial/deploy-replica-set/[Replica set]
* link:https://docs.mongodb.com/manual/core/replica-set-elections/[Replica set elections]
* link:https://docs.mongodb.com/manual/core/sharded-cluster-components/[Sharded cluster]
* link:https://docs.mongodb.com/manual/tutorial/add-shards-to-shard-cluster/[Shard addition]
* link:https://docs.mongodb.com/manual/tutorial/remove-shards-from-cluster/[Shard removal]

[[setting-up-mongodb]]
== Setting up MongoDB

The MongoDB connector uses MongoDB's oplog to capture the changes, so the connector works only with MongoDB replica sets or with sharded clusters where each shard is a separate replica set.
See the MongoDB documentation for setting up a https://docs.mongodb.com/manual/replication/[replica set] or https://docs.mongodb.com/manual/sharding/[sharded cluster].
Also, be sure to understand how to enable https://docs.mongodb.com/manual/tutorial/deploy-replica-set-with-keyfile-access-control/#deploy-repl-set-with-auth[access control and authentication] with replica sets.

You must also have a MongoDB user that has the appropriate roles to read the `admin` database where the oplog can be read. Additionally, the user must also be able to read the `config` database in the configuration server of a sharded cluster and must have `listDatabases` privilege action.

[[supported-mongodb-topologies]]
== Supported MongoDB topologies

The MongoDB connector can be used with a variety of MongoDB topologies.

[[mongodb-replicaset]]
=== MongoDB replica set

The MongoDB connector can capture changes from a single https://docs.mongodb.com/manual/replication/[MongoDB replica set].
Production replica sets require a minimum of https://docs.mongodb.com/manual/core/replica-set-architecture-three-members/[at least three members].

To use the MongoDB connector with a replica set, provide the addresses of one or more replica set servers as _seed addresses_ through the connector's `mongodb.hosts` property.
The connector will use these seeds to connect to the replica set, and then once connected will get from the replica set the complete set of members and which member is primary.
The connector will start a task to connect to the primary and capture the changes from the primary's oplog.
When the replica set elects a new primary, the task will automatically switch over to the new primary.

[NOTE]
====
When MongoDB is fronted by a proxy (such as with Docker on OS X or Windows), then when a client connects to the replica set and discovers the members, the MongoDB client will exclude the proxy as a valid member and will attempt and fail to connect directly to the members rather than go through the proxy.

In such a case, set the connector's optional `mongodb.members.auto.discover` configuration property to `false` to instruct the connector to forgo membership discovery and instead simply use the first seed address (specified via the `mongodb.hosts` property) as the primary node.
This may work, but still make cause issues when election occurs.
====

[[mongodb-sharded-cluster]]
=== MongoDB sharded cluster

A https://docs.mongodb.com/manual/sharding/[MongoDB sharded cluster] consists of:

* One or more _shards_, each deployed as a replica set;
* A separate replica set that acts as the cluster's _configuration server_
* One or more _routers_ (also called `mongos`) to which clients connect and that routes requests to the appropriate shards

To use the MongoDB connector with a sharded cluster, configure the connector with the host addresses of the _configuration server_ replica set. When the connector connects to this replica set, it discovers that it is acting as the configuration server for a sharded cluster, discovers the information about each replica set used as a shard in the cluster, and will then start up a separate task to capture the changes from each replica set. If new shards are added to the cluster or existing shards removed, the connector will automatically adjust its tasks accordingly.

[[mongodb-standalone-server]]
=== MongoDB standalone server

The MongoDB connector is not capable of monitoring the changes of a standalone MongoDB server, since standalone servers do not have an oplog.
The connector will work if the standalone server is converted to a replica set with one member.

[NOTE]
====
MongoDB https://docs.mongodb.com/manual/core/replica-set-architectures/[does not recommend] running a standalone server in production.
====


[[how-it-works]]
[[how-the-mongodb-connector-works]]
== How the MongoDB connector works

When a MongoDB connector is configured and deployed, it starts by connecting to the MongoDB servers at the seed addresses, and determines the details about each of the available replica sets.
Since each replica set has its own independent oplog, the connector will try to use a separate task for each replica set.
The connector can limit the maximum number of tasks it will use, and if not enough tasks are available the connector will assign multiple replica sets to each task, although the task will still use a separate thread for each replica set.

[NOTE]
====
When running the connector against a sharded cluster, use a value of `tasks.max` that is greater than the number of replica sets.
This will allow the connector to create one task for each replica set, and will let Kafka Connect coordinate, distribute, and manage the tasks across all of the available worker processes.
====

[[logical-name]]
[[logical-connector-name]]
=== Logical connector name

The connector configuration property `mongodb.name` serves as a _logical name_ for the MongoDB replica set or sharded cluster.
The connector uses the logical name in a number of ways: as the prefix for all topic names, and as a unique identifier when recording the oplog position of each replica set.

You should give each MongoDB connector a unique logical name that meaningfully describes the source MongoDB system.
We recommend logical names begin with an alphabetic or underscore character, and remaining characters that are alphanumeric or underscore.

[[initial-sync]]
=== Initial sync

When a task starts up using a replica set, it uses the connector's logical name and the replica set name to find an _offset_ that describes the position in the replica sets oplog where the connector previously stopped reading.
If an offset can be found and it is still in the oplog, then the task immediately proceeds with link:#tailing-the-oplog[tailing the oplog], starting at the recorded offset position.

However, if no offset is found or if the oplog no longer contains that position, the task must first obtain the current state of the replica set contents by performing an _initial sync_.
This process starts by recording the current position of the oplog and recording that as the offset (along with a flag that denotes an initial sync has been started).
The task will then proceed to copy each collection, spawning as many threads as possible (up to the value of the `initial.sync.max.threads` configuration property) to perform this work in parallel.
The connector will record a separate _read event_ for each document it sees, and that read event will contain the object's identifier, the complete state of the object, and _source_ information about the MongoDB replica set where the object was found.
The source information will also include a flag that denotes the event was produced during an initial sync.

This initial sync will continue until it has copied all collections that match the connector's filters.
If the connector is stopped before the tasks' initial syncs are completed, upon restart the connector begins the initial sync again.

[NOTE]
====
Try to avoid task reassignment and reconfiguration while the connector is performing an intial sync of any replica sets. The connector does log messages with the progress of the initial sync. For utmost control, run a separate cluster of Kafka Connect for each connector.
====

[[tailing-the-oplog]]
=== Tailing the oplog

Once the connector task for a replica set has an offset, it uses the offset to determine the position in the oplog where it should start reading.
The task will then connect to the replica set's primary node and start reading the oplog from that position, processing all of the create, insert, and delete operations and converting them into {prodname} link:#mongodb-events[change events]. Each change event includes the position in the oplog where the operation was found, and the connector periodically records this as its most recent offset. (The interval at which the offset is recorded is governed by the `offset.flush.interval.ms` http://docs.confluent.io/3.0.0/connect/userguide.html#configuring-workers[Kafka Connect worker configuration property].)

When the connector is stopped gracefully, the last offset processed is recorded so that, upon restart, the connector will continue exactly where it left off.
If the connector's tasks terminate unexpectedly, however, then the tasks may have processed and generated events after it last records the offset but before the last offset is recorded; upon restart, the connector begins at the last _recorded_ offset, possibly generating some the same events that were previously generated just prior to the crash.

[NOTE]
====
When everything is operating nominally, Kafka consumers will actually see every message *_exactly once_*. However, when things go wrong Kafka can only guarantee consumers will see every message *_at least once_*. Therefore, your consumers need to anticipate seeing messages more than once.
====

As mentioned above, the connector tasks always use the replica set's primary node to tail the oplog, ensuring that the connector sees the most up-to-date operations as possible and can capture the changes with lower latency than if secondaries were to be used instead. When the replica set elects a new primary, the connector will immediately stop tailing the oplog, connect to the new primary, and start tailing the new primary's oplog start at the same position. Likewise, if connector experiences any problems communicating with the replica set members, it will try to reconnect (using exponential backoff so as to not overwhelm the replica set) and once connected continue tailing the oplog from where it last left off. In this way the connector is able to dynamically adjust to changes in replica set membership and to automatically handle communication failures.

The bottom line is that the MongoDB connector will continue running under most situations, though communication problems may cause the connector to wait until the problems are resolved.

[[mongodb-topic-names]]
=== Topics names

The MongoDB connector writes events for all insert, update, and delete operations to documents in each collection to a single Kafka topic.
The name of the Kafka topics always takes the form _logicalName_._databaseName_._collectionName_, where _logicalName_ is the link:logical-name[logical name] of the connector as specified with the `mongodb.name` configuration property, _databaseName_ is the name of the database where the operation occurred, and _collectionName_ is the name of the MongoDB collection in which the affected document existed.

For example, consider a MongoDB replica set with an `inventory` database that contains four collections: `products`, `products_on_hand`, `customers`, and `orders`.
If the connector monitoring this database were given a logical name of `fulfillment`, then the connector would produce events on these four Kafka topics:

* `fulfillment.inventory.products`
* `fulfillment.inventory.products_on_hand`
* `fulfillment.inventory.customers`
* `fulfillment.inventory.orders`

Notice that the topic names do not incorporate the replica set name or shard name.
As a result, all changes to a sharded collection (where each shard contains a subset of the collection's documents) all go to the same Kafka topic.

You can set up Kafka to http://kafka.apache.org/documentation.html#basic_ops_add_topic[auto-create] the topics as they are needed.
If not, then you must use Kafka administration tools to create the topics before starting the connector.

[[partitions]]
=== Partitions

The MongoDB connector does not make any explicit determination of the topic partitions for events.
Instead, it allows Kafka to determine the partition based upon the key.
You can change Kafka's partitioning logic by defining in the Kafka Connect worker configuration the name of the `Partitioner` implementation.

Be aware that Kafka only maintains total order for events written to a single topic _partition_.
Partitioning the events by key does mean that all events with the same key will always go to the same partition, ensuring that all events for a specific document are always totally ordered.

[[mongodb-events]]
=== Events

All data change events produced by the MongoDB connector have a key and a value.

[NOTE]
====
Starting with Kafka 0.10, Kafka can optionally record with the message key and value the http://kafka.apache.org/documentation.html#upgrade_10_performance_impact[_timestamp_] at which the message was created (recorded by the producer) or written to the log by Kafka.
====

{prodname} and Kafka Connect are designed around _continuous streams of event messages_, and the structure of these events could potentially change over time if the source of those events changed in structure or if the connector is improved or changed.
This could be difficult for consumers to deal with, so to make it very easy Kafka Connect makes each event self-contained. Every message key and value has two parts: a _schema_ and _payload_. The schema describes the structure of the payload, while the payload contains the actual data.

[[mongodb-change-events-key]]
==== Change event's key

For a given collection, the change event's key contains a single `id` field.
Its value is the document's identifier represented as string which is derived from the https://docs.mongodb.com/manual/reference/mongodb-extended-json/[MongoDB extended JSON serialization in strict mode]. Consider a connector with a logical name of `fulfillment`, a replica set containing an `inventory` database with a `customers` collection containing documents such as:

[source,json,indent=0]
----
  {
    ""_id"": 1004,
    ""first_name"": ""Anne"",
    ""last_name"": ""Kretchmar"",
    ""email"": ""annek@noanswer.org""
  }
----

Every change event for the `customers` collection will feature the same key structure, which in JSON looks like this:

[source,json,indent=0]
----
  {
    ""schema"": {
      ""type"": ""struct"",
      ""name"": ""fulfillment.inventory.customers.Key""
      ""optional"": false,
      ""fields"": [
        {
          ""field"": ""id"",
          ""type"": ""string"",
          ""optional"": false
        }
      ]
    },
    ""payload"": {
      ""id"": ""1004""
    }
  }
----

The `schema` portion of the key contains a Kafka Connect schema describing what is in the payload portion, and in our case that means that the `payload` value is not optional, is a structure defined by a schema named `fulfillment.inventory.customers.Key`, and has one required field named `id` of type `string`. If we look at the value of the key's `payload` field, we'll see that it is indeed a structure (which in JSON is just an object) with a single `id` field, whose value is a string containing the integer `1004`.

This example used a document with an integer identifier, but any valid MongoDB document identifier (including documents) will work. The value of the `id` field in the payload will simply be a string representing a MongoDB extended JSON serialization (strict mode) of the original document's `_id` field. Find below a few examples showing how `_id` fields of
different types will get encoded as the event key's payload:

[options=""header"",role=""code-wordbreak-col2 code-wordbreak-col3""]
|==========================================
|Type    |MongoDB `_id` Value|Key's payload
|Integer |1234|`{ ""id"" : ""1234"" }`
|Float   |12.34|`{ ""id"" : ""12.34"" }`
|String  |""1234""|`{ ""id"" : ""\\""1234\\"""" }`
|Document|{ ""hi"" : ""kafka"", ""nums"" : [10.0, 100.0, 1000.0] }|`{ ""id"" : ""{\\""hi\\"" : \\""kafka\\"", \\""nums\\"" : [10.0, 100.0, 1000.0]}"" }`
|ObjectId|ObjectId(""596e275826f08b2730779e1f"")|`{ ""id"" : ""{\\""$oid\\"" : \\""596e275826f08b2730779e1f\\""}"" }`
|Binary  |BinData(""a2Fma2E="",0)|`{ ""id"" : ""{\\""$binary\\"" : \\""a2Fma2E=\\"", \\""$type\\"" : \\""00\\""}"" }`
|==========================================

ifndef::cdc-product[]
[WARNING]
====
The MongoDB connector ensures that all Kafka Connect _schema names_ are http://avro.apache.org/docs/current/spec.html#names[valid Avro schema names]. This means that the logical server name must start with Latin letters or an underscore (e.g., [a-z,A-Z,\\_]), and the remaining characters in the logical server name and all characters in the database and collections names must be Latin letters, digits, or an underscore (e.g., [a-z,A-Z,0-9,\\_]). If not, then all invalid characters will automatically be replaced with an underscore character.

This can lead to unexpected conflicts in schemas names when the logical server name, database names, and table names contain other characters, and the only distinguishing characters between table full names are invalid and thus replaced with underscores. The connector attempts to produce an exception in this such cases, but only when the conflicts exist between schemas used within a single connector.
====
endif::cdc-product[]

[[mongodb-change-events-value]]
==== Change event's value

The value of the change event message is a bit more complicated.
Like the key message, it has a _schema_ section and _payload_ section.
The payload section of every change event value produced by the MongoDB connector has an _envelope_ structure with the following fields:

* `op` is a mandatory field that contains a string value describing the type of operation. Values for the MongoDB connector are `c` for create (or insert), `u` for update, `d` for delete, and `r` for read (in the case of a initial sync).
* `after` is an optional field that if present contains the state of the document _after_ the event occurred. MongoDB's oplog entries only contain the full state of a document for _create_ events, so these are the only events that contain an _after_ field.
* `source` is a mandatory field that contains a structure describing the source metadata for the event, which in the case of MongoDB contains several fields: the {prodname} version, the logical name, the replica set's name, the namespace of the collection, the MongoDB timestamp (and ordinal of the event within the timestamp) at which the event occurred, the identifier of the MongoDB operation (e.g., the `h` field in the oplog event), and the initial sync flag if the event resulted during an intial sync.
* `ts_ms` is optional and if present contains the time (using the system clock in the JVM running the Kafka Connect task) at which the connector processed the event.

And of course, the _schema_ portion of the event message's value contains a schema that describes this envelope structure and the nested fields within it.

Let's look at what a _create_/_read_ event value might look like for our `customers` table:

[source,json,indent=0,subs=""attributes""]
----
{
    ""schema"": {
      ""type"": ""struct"",
      ""fields"": [
        {
          ""type"": ""string"",
          ""optional"": true,
          ""name"": ""io.debezium.data.Json"",
          ""version"": 1,
          ""field"": ""after""
        },
        {
          ""type"": ""string"",
          ""optional"": true,
          ""name"": ""io.debezium.data.Json"",
          ""version"": 1,
          ""field"": ""patch""
        },
        {
          ""type"": ""struct"",
          ""fields"": [
            {
              ""type"": ""string"",
              ""optional"": false,
              ""field"": ""version""
            },
            {
              ""type"": ""string"",
              ""optional"": false,
              ""field"": ""connector""
            },
            {
              ""type"": ""string"",
              ""optional"": false,
              ""field"": ""name""
            },
            {
              ""type"": ""int64"",
              ""optional"": false,
              ""field"": ""ts_ms""
            },
            {
              ""type"": ""boolean"",
              ""optional"": true,
              ""default"": false,
              ""field"": ""snapshot""
            },
            {
              ""type"": ""string"",
              ""optional"": false,
              ""field"": ""db""
            },
            {
              ""type"": ""string"",
              ""optional"": false,
              ""field"": ""rs""
            },
            {
              ""type"": ""string"",
              ""optional"": false,
              ""field"": ""collection""
            },
            {
              ""type"": ""int32"",
              ""optional"": false,
              ""field"": ""ord""
            },
            {
              ""type"": ""int64"",
              ""optional"": true,
              ""field"": ""h""
            }
          ],
          ""optional"": false,
          ""name"": ""io.debezium.connector.mongo.Source"",
          ""field"": ""source""
        },
        {
          ""type"": ""string"",
          ""optional"": true,
          ""field"": ""op""
        },
        {
          ""type"": ""int64"",
          ""optional"": true,
          ""field"": ""ts_ms""
        }
      ],
      ""optional"": false,
      ""name"": ""dbserver1.inventory.customers.Envelope""
      },
    ""payload"": {
      ""after"": ""{\\""_id\\"" : {\\""$numberLong\\"" : \\""1004\\""},\\""first_name\\"" : \\""Anne\\"",\\""last_name\\"" : \\""Kretchmar\\"",\\""email\\"" : \\""annek@noanswer.org\\""}"",
      ""patch"": null,
      ""source"": {
        ""version"": ""{debezium-version}"",
        ""connector"": ""mongodb"",
        ""name"": ""fulfillment"",
        ""ts_ms"": 1558965508000,
        ""snapshot"": true,
        ""db"": ""inventory"",
        ""rs"": ""rs0"",
        ""collection"": ""customers"",
        ""ord"": 31,
        ""h"": 1546547425148721999
      },
      ""op"": ""r"",
      ""ts_ms"": 1558965515240
    }
  }
----

If we look at the `schema` portion of this event's _value_, we can see the schema for the _envelope_ is specific to the collection, and the schema for the `source` structure (which is specific to the MongoDB connector and reused across all events). Also note that the `after` value is always a string, and that by convention it will contain a JSON representation of the document.

If we look at the `payload` portion of this event's _value_, we can see the information in the event, namely that it is describing that the document was read as part of an initial sync (since `op=r` and `initsync=true`), and that the `after` field value contains the JSON string representation of the document.

[NOTE]
====
It may appear that the JSON representations of the events are much larger than the rows they describe. This is true, because the JSON representation must include the _schema_ and the _payload_ portions of the message.
ifndef::cdc-product[]
It is possible and even recommended to use the link:/docs/faq/#avro-converter[Avro Converter] to dramatically decrease the size of the actual messages written to the Kafka topics.
endif::cdc-product[]
====

The value of an _update_ change event on this collection will actually have the exact same _schema_, and its payload is structured the same but will hold different values. Specifically, an update event will not have an `after` value and will instead have a `patch` string containing the JSON representation of the idempotent update operation. Here's an example:

[source,json,indent=0,subs=""attributes""]
----
{
    ""schema"": { ... },
    ""payload"": {
      ""op"": ""u"",
      ""ts_ms"": 1465491461815,
      ""patch"": ""{\\""$set\\"":{\\""first_name\\"":\\""Anne Marie\\""}}"",
      ""source"": {
        ""version"": ""{debezium-version}"",
        ""connector"": ""mongodb"",
        ""name"": ""fulfillment"",
        ""ts_ms"": 1558965508000,
        ""snapshot"": true,
        ""db"": ""inventory"",
        ""rs"": ""rs0"",
        ""collection"": ""customers"",
        ""ord"": 6,
        ""h"": 1546547425148721999
      }
    }
  }
----

When we compare this to the value in the _insert_ event, we see a couple of differences in the `payload` section:

* The `op` field value is now `u`, signifying that this document changed because of an update
* The `patch` field appears and has the stringified JSON representation of the actual MongoDB idempotent change to the document, which in this example involves setting the `first_name` field to a new value
* The `after` field no longer appears
* The `source` field structure has the same fields as before, but the values are different since this event is from a different position in the oplog
* The `ts_ms` shows the timestamp that {prodname} processed this event

[WARNING]
====
The content of the patch field is provided by MongoDB itself and its exact format depends on the specific database version.
You should therefore be prepared for potential changes to the format when upgrading the MongoDB instance to a new version.

All examples in this document were obtained from MongoDB 3.4 and might differ if you use a different one.
====

[NOTE]
====
Update events in MongoDB's oplog don't have the _before_ or _after_ states of the changed document, so there's no way for the connector to provide this information.
However, because _create_ or _read_ events _do_ contain the starting state, downstream consumers of the stream can actually fully-reconstruct the state by keeping the latest state for each document and applying each event to that state. {prodname} connector's are not able to keep such state, so it is not able to do this.
====

So far we've seen samples of _create_/_read_ and _update_ events. Now, let's look at the value of a _delete_ event for the same table.
The value of an _delete_ event on this collection will also have the exact same _schema_, and its payload is structured the same but will hold different values.
In particular, a delete event will not have an `after` value or a `patch` value:

[source,json,indent=0,subs=""attributes""]
----
{
    ""schema"": { ... },
    ""payload"": {
      ""op"": ""d"",
      ""ts_ms"": 1465495462115,
      ""source"": {
        ""version"": ""{debezium-version}"",
        ""connector"": ""mongodb"",
        ""name"": ""fulfillment"",
        ""ts_ms"": 1558965508000,
        ""snapshot"": true,
        ""db"": ""inventory"",
        ""rs"": ""rs0"",
        ""collection"": ""customers"",
        ""ord"": 6,
        ""h"": 1546547425148721999
      }
    }
  }
----

When we compare this to the value in the other events, we see a couple of differences in the `payload` section:

* The `op` field value is now `d`, signifying that this document was deleted
* The `patch` field does not appear
* The `after` field does not appear
* The `source` field structure has the same fields as before, but the values are different since this event is from a different position in the oplog
* The `ts_ms` shows the timestamp that {prodname} processed this event

The MongoDB connector actually provides one other kind of event. Each _delete_ event is followed by a _tombstone_ event that has the same key but a `null` value, giving Kafka enough information to know that its https://cwiki.apache.org/confluence/display/KAFKA/Log+Compaction[Kafka log compaction] mechanism can remove _all_ messages with that key.

[NOTE]
====
All MongoDB connector events are designed to work with https://cwiki.apache.org/confluence/display/KAFKA/Log+Compaction[Kafka log compaction], which allows for the removal of older messages as long as at least the most recent message for every key is kept. This is how Kafka can reclaim storage space while ensuring the topic contains a complete dataset and can be used for reloading key-based state.

All MongoDB connector events for a uniquely identified document will have exactly the same key, signaling to Kafka that only the latest event be kept.
And, a tombstone event informs Kafka that _all_ messages with that same key can be removed.
====

[[configuration]]
[[mongodb-deploying-a-connector]]
== Deploying the MongoDB connector

ifndef::cdc-product[]
If you've already installed https://zookeeper.apache.org[Zookeeper], http://kafka.apache.org/[Kafka], and http://kafka.apache.org/documentation.html#connect[Kafka Connect], then using Debezium's MongoDB connector is easy. Simply download the https://repo1.maven.org/maven2/io/debezium/debezium-connector-mongodb/0.3.0/debezium-connector-mongodb-0.3.0-plugin.tar.gz[connector's plugin archive], extract the JARs into your Kafka Connect environment, and add the directory with the JARs to http://docs.confluent.io/3.0.0/connect/userguide.html#installing-connector-plugins[Kafka Connect's classpath]. Restart your Kafka Connect process to pick up the new JARs.
endif::cdc-product[]

ifdef::cdc-product[]
Installing the MongoDB connector is a simple process whereby you only need to download the JAR, extract it to your Kafka Connect environment, and ensure the plugin's parent directory is specified in your Kafka Connect environment.

.Prerequisites

* You have link:https://zookeeper.apache.org/[Zookeeper], link:http://kafka.apache.org/[Kafka], and link:http://kafka.apache.org/documentation.html#connect[Kafka Connect] installed.
* You have MongoDB installed and setup.

.Procedure

. Visit link:https://access.redhat.com/jbossnetwork/restricted/listSoftware.html?downloadType=distributions&product=jboss.amq.streams[Product Downloads^] on the Red Hat Customer Portal and download the MongoDB connector.
. Extract the files into your Kafka Connect environment.
. Add the plugin's parent directory to your Kafka Connect plugin path:
+
[source]
----
plugin.path=/kafka/connect
----

NOTE: The above example assumes you have extracted the {prodname} MongoDB connector to the `/kafka/connect/{prodname}-connector-mongodb` path.

[start=4]
. Restart your Kafka Connect process. This ensures the new JARs are picked up.

.Additional resources

For more information on the deployment process, and deploying connectors with AMQ Streams, refer to the {prodname} installation guides.

* link:https://access.redhat.com/documentation/en-us/red_hat_integration/2019-12/html-single/installing_change_data_capture_on_openshift[Installing {prodname} on OpenShift]
* link:https://access.redhat.com/documentation/en-us/red_hat_integration/2019-12/html-single/installing_change_data_capture_on_rhel[Installing {prodname} on RHEL]
endif::cdc-product[]

ifndef::cdc-product[]
If immutable containers are your thing, then check out https://hub.docker.com/r/debezium/[Debezium's Docker images] for Zookeeper, Kafka, and Kafka Connect with the MongoDB connector already pre-installed and ready to go.
Our xref:tutorial.adoc[tutorial] even walks you through using these images, and this is a great way to learn what Debezium is all about. You can even link:/blog/2016/05/31/Debezium-on-Kubernetes/[run Debezium on Kubernetes and OpenShift].
endif::cdc-product[]

[[example]]
[[mongodb-example-configuration]]
=== Example configuration

To use the connector to produce change events for a particular MongoDB replica set or sharded cluster, create a configuration file in JSON.
When the connector starts, it will perform an initial sync of the collections in your MongoDB replica sets and start reading the replica sets' oplogs, producing events for every inserted, updated, and deleted row.
Optionally filter out collections that are not needed.

Here is an example of the configuration for a MongoDB connector that monitors a MongoDB replica set `rs0` at port 27017 on 192.168.99.100, which we logically name `fullfillment`:

[source,json]
----
{
  ""name"": ""inventory-connector"",  // <1>
  ""config"": {
    ""connector.class"": ""io.debezium.connector.mongodb.MongoDbConnector"", // <2>
    ""mongodb.hosts"": ""rs0/192.168.99.100:27017"", // <3>
    ""mongodb.name"": ""fullfillment"", // <4>
    ""collection.whitelist"": ""inventory[.]*"", // <5>
  }
}
----
<1> The name of our connector when we register it with a Kafka Connect service.
<2> The name of the MongoDB connector class.
<3> The host addresses to use to connect to the MongoDB replica set
<4> The _logical name_ of the MongoDB replica set, which forms a namespace for generated events and is used in all the names of the Kafka topics to which the connector writes, the Kafka Connect schema names, and the namespaces of the corresponding Avro schema when the Avro Connector is used.
<5> A list of regular expressions that match the collection namespaces (e.g., <dbName>.<collectionName>) of all collections to be monitored. This is optional.

See the link:#mongodb-connector-properties[complete list of connector properties] that can be specified in these configurations.

This configuration can be sent via POST to a running Kafka Connect service, which will then record the configuration and start up the one connector task that will connect to the MongoDB replica set or sharded cluster, assign tasks for each replica set, perform an initial sync if necessary, read the oplog, and record events to Kafka topics.


[[mongodb-connector-properties]]
=== Connector properties

The following configuration properties are _required_ unless a default value is available.

[cols=""35%a,10%a,55%a""]
|=======================
|Property |Default |Description

|`name`
|
|Unique name for the connector. Attempting to register again with the same name will fail. (This property is required by all Kafka Connect connectors.)

|`connector.class`
|
|The name of the Java class for the connector. Always use a value of `io.debezium.connector.mongodb.MongoDbConnector` for the MongoDB connector.

|`mongodb.hosts`
|
|The comma-separated list of hostname and port pairs (in the form 'host' or 'host:port') of the MongoDB servers in the replica set. The list can contain a single hostname and port pair. If `mongodb.members.auto.discover` is set to `false`, then the host and port pair should be prefixed with the replica set name (e.g., `rs0/localhost:27017`).

|`mongodb.name`
|
|A unique name that identifies the connector and/or MongoDB replica set or sharded cluster that this connector monitors. Each server should be monitored by at most one {prodname} connector, since this server name prefixes all persisted Kafka topics emanating from the MongoDB replica set or cluster.

|`mongodb.user`
|
|Name of the database user to be used when connecting to MongoDB. This is required only when MongoDB is configured to use authentication.

|`mongodb.password`
|
|Password to be used when connecting to MongoDB. This is required only when MongoDB is configured to use authentication.

|`mongodb.authsource`
|`admin`
|Database (authentication source) containing MongoDB credentials. This is required only when MongoDB is configured to use authentication with another authentication database than `admin`.

|`mongodb.ssl.enabled`
|`false`
|Connector will use SSL to connect to MongoDB instances.

|`mongodb.ssl.invalid.hostname.allowed`
|`false`
|When SSL is enabled this setting controls whether strict hostname checking is disabled during connection phase. If `true` the connection will not prevent man-in-the-middle attacks.

|`database.whitelist`
|_empty string_
|An optional comma-separated list of regular expressions that match database names to be monitored; any database name not included in the whitelist is excluded from monitoring. By default all databases is monitored.
May not be used with `database.blacklist`.

|`database.blacklist`
|_empty string_
|An optional comma-separated list of regular expressions that match database names to be excluded from monitoring; any database name not included in the blacklist is monitored. May not be used with `database.whitelist`.

|`collection.whitelist`
|_empty string_
|An optional comma-separated list of regular expressions that match fully-qualified namespaces for MongoDB collections to be monitored; any collection not included in the whitelist is excluded from monitoring. Each identifier is of the form _databaseName_._collectionName_. By default the connector will monitor all collections except those in the `local` and `admin` databases. May not be used with `collection.blacklist`.

|`collection.blacklist`
|_empty string_
|An optional comma-separated list of regular expressions that match fully-qualified namespaces for MongoDB collections to be excluded from monitoring; any collection not included in the blacklist is monitored. Each identifier is of the form _databaseName_._collectionName_. May not be used with `collection.whitelist`.

|`snapshot.mode`
|`initial`
|Specifies the criteria for running a snapshot (eg. initial sync) upon startup of the connector. The default is *initial*, and specifies the connector reads a snapshot when either no offset is found or if the oplog no longer contains the previous offset. The *never* option specifies that the connector should never use snapshots, instead the connector should proceed to tail the log.

|`field.blacklist`
|_empty string_
|An optional comma-separated list of the fully-qualified names of fields that should be excluded from change event message values. Fully-qualified names for fields are of the form _databaseName_._collectionName_._fieldName_._nestedFieldName_, where _databaseName_ and _collectionName_ may contain the wildcard (*) which matches any characters.

|`field.renames`
|_empty string_
|An optional comma-separated list of the fully-qualified replacements of fields that should be used to rename fields in change event message values. Fully-qualified replacements for fields are of the form _databaseName_._collectionName_._fieldName_._nestedFieldName_:__newNestedFieldName__, where _databaseName_ and _collectionName_ may contain the wildcard (*) which matches any characters, the colon character (:) is used to determine rename mapping of field. The next field replacement is applied to the result of the previous field replacement in the list, so keep this in mind when renaming multiple fields that are in the same path.

|`tasks.max`
|`1`
|The maximum number of tasks that should be created for this connector. The MongoDB connector will attempt to use a separate task for each replica set, so the default is acceptable when using the connector with a single MongoDB replica set. When using the connector with a MongoDB sharded cluster, we recommend specifying a value that is equal to or more than the number of shards in the cluster, so that the work for each replica set can be distributed by Kafka Connect.

|`initial.sync.max.threads`
|`1`
|Positive integer value that specifies the maximum number of threads used to perform an intial sync of the collections in a replica set. Defaults to 1.

|`tombstones.on.delete`
|`true`
| Controls whether a tombstone event should be generated after a delete event. +
When `true` the delete operations are represented by a delete event and a subsequent tombstone event. When `false` only a delete event is sent. +
Emitting the tombstone event (the default behavior) allows Kafka to completely delete all events pertaining to the given key once the source record got deleted.

|`snapshot.delay.ms`
|
|An interval in milli-seconds that the connector should wait before taking a snapshot after starting up; +
Can be used to avoid snapshot interruptions when starting multiple connectors in a cluster, which may cause re-balancing of connectors.

|`snapshot.fetch.size`
|`0`
|Specifies the maximum number of documents that should be read in one go from each collection while taking a snapshot.
The connector will read the collection contents in multiple batches of this size. +
Defaults to 0, which indicates that the server chooses an appropriate fetch size.

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


The following _advanced_ configuration properties have good defaults that will work in most situations and therefore rarely need to be specified in the connector's configuration.

[cols=""35%a,10%a,55%a"",options=""header""]
|=======================
|Property
|Default
|Description

|`max.queue.size`
|`8192`
|Positive integer value that specifies the maximum size of the blocking queue into which change events read from the database log are placed before they are written to Kafka. This queue can provide backpressure to the oplog reader when, for example, writes to Kafka are slower or if Kafka is not available. Events that appear in the queue are not included in the offsets periodically recorded by this connector. Defaults to 8192, and should always be larger than the maximum batch size specified in the `max.batch.size` property.

|`max.batch.size`
|`2048`
|Positive integer value that specifies the maximum size of each batch of events that should be processed during each iteration of this connector. Defaults to 2048.

|`poll.interval.ms`
|`1000`
|Positive integer value that specifies the number of milliseconds the connector should wait during each iteration for new change events to appear. Defaults to 1000 milliseconds, or 1 second.

|`connect.backoff.initial.delay.ms`
|`1000`
|Positive integer value that specifies the initial delay when trying to reconnect to a primary after the first failed connection attempt or when no primary is available. Defaults to 1 second (1000 ms).

|`connect.backoff.max.delay.ms`
|`1000`
|Positive integer value that specifies the maximum delay when trying to reconnect to a primary after repeated failed connection attempts or when no primary is available. Defaults to 120 seconds (120,000 ms).

|`connect.max.attempts`
|`16`
|Positive integer value that specifies the maximum number of failed connection attempts to a replica set primary before an exception occurs and task is aborted. Defaults to 16, which with the defaults for `connect.backoff.initial.delay.ms` and `connect.backoff.max.delay.ms` results in just over 20 minutes of attempts before failing.

|`mongodb.members.auto.discover`
|`true`
|Boolean value that specifies whether the addresses in 'mongodb.hosts' are seeds that should be used to discover all members of the cluster or replica set (`true`), or whether the address(es) in `mongodb.hosts` should be used as is (`false`). The default is `true` and should be used in all cases except where MongoDB is link:#mongodb-replicaset[fronted by a proxy].

|`source.struct.version`
|v2
|Schema version for the `source` block in CDC events. Debezium 0.10 introduced a few breaking +
changes to the structure of the `source` block in order to unify the exposed structure across
all the connectors. +
By setting this option to `v1` the structure used in earlier versions can be produced.
Note that this setting is not recommended and is planned for removal in a future {prodname} version.

|`heartbeat.interval.ms`
|`0`
|Controls how frequently heartbeat messages are sent. +
This property contains an interval in milli-seconds that defines how frequently the connector sends messages into a heartbeat topic.
This can be used to monitor whether the connector is still receiving change events from the database.
You also should leverage heartbeat messages in cases where only records in non-captured collections are changed for a longer period of time.
In such situation the connector would proceed to read the oplog from the database but never emit any change messages into Kafka,
which in turn means that no offset updates are committed to Kafka.
This will cause the oplog files to be rotated out but connector will not notice it so on restart some events are no longer available which leads to the need of re-execution of the initial snapshot.

Set this parameter to `0` to not send heartbeat messages at all. +
Disabled by default.

|`heartbeat.topics.prefix`
|`__debezium-heartbeat`
|Controls the naming of the topic to which heartbeat messages are sent. +
The topic is named according to the pattern `<heartbeat.topics.prefix>.<server.name>`.

|`sanitize.field.names`
|`true` when connector configuration explicitly specifies the `key.converter` or `value.converter` parameters to use Avro, otherwise defaults to `false`.
|Whether field names are sanitized to adhere to Avro naming requirements.
ifndef::cdc-product[]
See xref:configuration/avro.adoc#names[Avro naming] for more details.
endif::cdc-product[]
|=======================

[[fault-tolerance]]
[[mongodb-when-things-go-wrong]]
== MongoDB connector common issues

{prodname} is a distributed system that captures all changes in multiple upstream databases, and will never miss or lose an event. Of course, when the system is operating nominally or being administered carefully, then {prodname} provides _exactly once_ delivery of every change event. However, if a fault does happen then the system will still not lose any events, although while it is recovering from the fault it may repeat some change events. Thus, in these abnormal situations {prodname} (like Kafka) provides _at least once_ delivery of change events.

The rest of this section describes how {prodname} handles various kinds of faults and problems.

=== Configuration and startup errors

The connector will fail upon startup, report an error/exception in the log, and stop running when the connector's configuration is invalid, or when the connector repeatedly fails to connect to MongoDB using the specified connectivity parameters. Reconnection is done using exponential backoff, and the maximum number of attempts is configurable.

In these cases, the error will have more details about the problem and possibly a suggested work around. The connector can be restarted when the configuration has been corrected or the MongoDB problem has been addressed.

=== MongoDB becomes unavailable

Once the connector is running, if the primary node of any of the MongoDB replica sets become unavailable or unreachable, the connector will repeatedly attempt to reconnect to the primary node, using exponential backoff to prevent saturating the network or servers. If the primary remains unavailable after the configurable number of connection attempts, the connector will fail.

The attempts to reconnect are controlled by three properties:

* `connect.backoff.initial.delay.ms` - The delay before attempting to reconnect for the first time, with a default of 1 second (1000 milliseconds).
* `connect.backoff.max.delay.ms` - The maximum delay before attempting to reconnect, with a default of 120 seconds (120,000 milliseconds).
* `connect.max.attempts` - The maximum number of attempts before an error is produced, with a default of 16.

Each delay is double that of the prior delay, up to the maximum delay. Given the default values, the following table shows the delay for each failed connection attempt and the total accumulated time before failure.

[cols=""30%a,30%a,40%a"",options=""header""]
|=======================
|Reconnection attempt number
|Delay before attempt, in seconds
|Total delay before attempt, in minutes and seconds

|1 |1 |00:01
|2 |2 |00:03
|3 |4 |00:07
|4 |8 |00:15
|5 |16 |00:31
|6 |32 |01:03
|7 |64 |02:07
|8 |120|04:07
|9 |120|06:07
|10 |120|08:07
|11 |120|10:07
|12 |120|12:07
|13 |120|14:07
|14 |120|16:07
|15 |120|18:07
|16 |120|20:07
|=======================


=== Kafka Connect process stops gracefully

If Kafka Connect is being run in distributed mode, and a Kafka Connect process is stopped gracefully, then prior to shutdown of that processes Kafka Connect will migrate all of the process' connector tasks to another Kafka Connect process in that group, and the new connector tasks will pick up exactly where the prior tasks left off.
There is a short delay in processing while the connector tasks are stopped gracefully and restarted on the new processes.

If the group contains only one process and that process is stopped gracefully, then Kafka Connect will stop the connector and record the last offset for each replica set. Upon restart, the replica set tasks will continue exactly where they left off.

=== Kafka Connect process crashes

If the Kafka Connector process stops unexpectedly, then any connector tasks it was running will terminate without recording their most recently-processed offsets.
When Kafka Connect is being run in distributed mode, it will restart those connector tasks on other processes.
However, the MongoDB connectors will resume from the last offset _recorded_ by the earlier processes, which means that the new replacement tasks may generate some of the same change events that were processed just prior to the crash.
The number of duplicate events depends on the offset flush period and the volume of data changes just before the crash.

[NOTE]
====
Because there is a chance that some events may be duplicated during a recovery from failure, consumers should always anticipate some events may be duplicated. {prodname} changes are idempotent, so a sequence of events always results in the same state.

{prodname} also includes with each change event message the source-specific information about the origin of the event, including the MongoDB event's unique transaction identifier (`h`) and timestamp (`sec` and `ord`). Consumers can keep track of other of these values to know whether it has already seen a particular event.
====

=== Kafka becomes unavailable

As the connector generates change events, the Kafka Connect framework records those events in Kafka using the Kafka producer API. Kafka Connect will also periodically record the latest offset that appears in those change events, at a frequency you've specified in the Kafka Connect worker configuration. If the Kafka brokers become unavailable, the Kafka Connect worker process running the connectors will simply repeatedly attempt to reconnect to the Kafka brokers. In other words, the connector tasks will simply pause until a connection can be reestablished, at which point the connectors will resume exactly where they left off.

=== Connector is stopped for a duration

If the connector is gracefully stopped, the replica sets can continue to be used and any new changes are recorded in MongoDB's oplog.
When the connector is restarted, it will resume reading the oplog for each replica set where it last left off, recording change events for all of the changes that were made while the connector was stopped. If the connector is stopped long enough such that MongoDB purges from its oplog some operations that the connector has not read, then upon startup the connector will perform an initial sync.

A properly configured Kafka cluster is capable of https://engineering.linkedin.com/kafka/benchmarking-apache-kafka-2-million-writes-second-three-cheap-machines[massive throughput].
Kafka Connect is written with Kafka best practices, and given enough resources will also be able to handle very large numbers of database change events. Because of this, when a connector has been restarted after a while, it is very likely to catch up with the database, though how quickly will depend upon the capabilities and performance of Kafka and the volume of changes being made to the data in MongoDB.

[NOTE]
====
If the connector remains stopped for long enough, MongoDB might purge older oplog files and the connector's last position may be lost.
In this case, when the connector configured with _initial_ snapshot mode (the default) is finally restarted, the MongoDB server will no longer have the starting point and the connector will fail with an error.
====

=== MongoDB loses writes

It is possible for MongoDB to lose commits in specific failure situations. For example, if the primary applies a change and records it in its oplog before it then crashes unexpectedly, the secondary nodes may not have had a chance to read those changes from the primary's oplog before the primary crashed. If one such secondary is then elected as primary, it's oplog is missing the last changes that the old primary had recorded and no longer has those changes.

In these cases where MongoDB loses changes recorded in a primary's oplog, it is possible that the MongoDB connector may or may not capture these lost changes. At this time, there is no way to prevent this side effect of MongoDB.
",12478,False,1947.7224794951476,median
"= AsciidoctorJ: Java bindings for Asciidoctor
Alex Soto <https://github.com/lordofthejars[@lordofthejars]>; Dan Allen <https://github.com/mojavelinux[@mojavelinux]>
// Settings:
:compat-mode!:
:page-layout: base
:toc: macro
:toclevels: 2
ifdef::awestruct[:toclevels: 1]
:experimental:
//:table-caption!:
:source-language: java
:language: {source-language}
ifdef::env-github[:badges:]
// Aliases:
:dagger: &#8224;
// URIs:
ifdef::awestruct[:uri-docs: link:/docs]
ifndef::awestruct[:uri-docs: http://asciidoctor.org/docs]
:uri-asciidoctor: {uri-docs}/what-is-asciidoctor
:uri-repo: https://github.com/asciidoctor/asciidoctorj
:uri-issues: {uri-repo}/issues
:uri-discuss: http://discuss.asciidoctor.org
:artifact-version: 2.1.0
:uri-maven-artifact-query: http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.asciidoctor%22%20AND%20a%3A%22asciidoctorj%22%20AND%20v%3A%22{artifact-version}%22
:uri-maven-artifact-detail: http://search.maven.org/#artifactdetails%7Corg.asciidoctor%7Casciidoctorj%7C{artifact-version}%7Cjar
:uri-maven-artifact-file: http://search.maven.org/remotecontent?filepath=org/asciidoctor/asciidoctorj/{artifact-version}/asciidoctorj-{artifact-version}
:uri-maven-artifact-api-query: http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.asciidoctor%22%20AND%20a%3A%22asciidoctorj-api%22%20AND%20v%3A%22{artifact-version}%22
:uri-maven-artifact-api-detail: http://search.maven.org/#artifactdetails%7Corg.asciidoctor%7Casciidoctorj-api%7C{artifact-version}%7Cjar
:uri-maven-artifact-api-file: http://search.maven.org/remotecontent?filepath=org/asciidoctor/asciidoctorj-api/{artifact-version}/asciidoctorj-api-{artifact-version}
:uri-bintray-artifact-query: https://bintray.com/asciidoctor/maven/asciidoctorj/view/general
:uri-bintray-artifact-detail: https://bintray.com/asciidoctor/maven/asciidoctorj/{artifact-version}/view
:uri-bintray-artifact-file: http://dl.bintray.com/asciidoctor/maven/org/asciidoctor/asciidoctorj/{artifact-version}/asciidoctorj-{artifact-version}
:uri-bintray-artifact-api-query: https://bintray.com/asciidoctor/maven/asciidoctorj-api/view/general
:uri-bintray-artifact-api-detail: https://bintray.com/asciidoctor/maven/asciidoctorj-api/{artifact-version}/view
:uri-bintray-artifact-api-file: http://dl.bintray.com/asciidoctor/maven/org/asciidoctor/asciidoctorj-api/{artifact-version}/asciidoctorj-api-{artifact-version}
:uri-jruby-startup: http://github.com/jruby/jruby/wiki/Improving-startup-time
:uri-maven-guide: {uri-docs}/install-and-use-asciidoctor-maven-plugin
:uri-gradle-guide: {uri-docs}/install-and-use-asciidoctor-gradle-plugin
:uri-tilt: https://github.com/rtomayko/tilt
:uri-font-awesome: http://fortawesome.github.io/Font-Awesome
:uri-gradle: https://gradle.org
:uri-chocolatey: https://chocolatey.org

{uri-repo}[AsciidoctorJ] is the official library for running {uri-asciidoctor}[Asciidoctor] on the JVM.
Using AsciidoctorJ, you can convert AsciiDoc content or analyze the structure of a parsed AsciiDoc document from Java and other JVM languages.

ifdef::badges[]
image:https://img.shields.io/travis/asciidoctor/asciidoctorj/master.svg[Build Status (Travis CI), link=https://travis-ci.org/asciidoctor/asciidoctorj]
image:https://ci.appveyor.com/api/projects/status/syxrlv047esal4n0/branch/master?svg=true[Build Status (AppVeyor), link=https://ci.appveyor.com/project/asciidoctor/asciidoctorj]
image:https://img.shields.io/badge/javadoc.io-1.6.0-blue.svg[Javadoc, link=http://www.javadoc.io/doc/org.asciidoctor/asciidoctorj/1.6.0-alpha.1]
endif::[]

ifdef::awestruct,env-browser[]
toc::[]
endif::[]

== Distribution

AsciidoctorJ is published to Maven Central and Bintray.
The artifact information can be found in the tables below.

[cols=""2,2,^2,4""]
.Artifact information for AsciidoctorJ in jCenter (Bintray)
|===
|Group Id |Artifact Id |Version |Download

|org.asciidoctor
|{uri-bintray-artifact-query}[asciidoctorj]
|{uri-bintray-artifact-detail}[{artifact-version}]
|{uri-bintray-artifact-file}.pom[pom] {uri-bintray-artifact-file}.jar[jar] {uri-bintray-artifact-file}-javadoc.jar[javadoc (jar)] {uri-bintray-artifact-file}-sources.jar[sources (jar)] {uri-bintray-artifact-file}-bin.zip[distribution (zip)]

|org.asciidoctor
|{uri-bintray-artifact-api-query}[asciidoctorj-api]
|{uri-bintray-artifact-api-detail}[{artifact-version}]
|{uri-bintray-artifact-api-file}.pom[pom] {uri-bintray-artifact-api-file}.jar[jar] {uri-bintray-artifact-api-file}-javadoc.jar[javadoc (jar)] {uri-bintray-artifact-api-file}-sources.jar[sources (jar)]

|org.asciidoctor
|asciidoctorj-epub3
|1.5.0-alpha.9
|{empty}

|org.asciidoctor
|asciidoctorj-pdf
|1.5.0-alpha.18
|{empty}
|===

[cols=""2,2,^2,4""]
.Artifact information for AsciidoctorJ in Maven Central
|===
|Group Id |Artifact Id |Version |Download

|org.asciidoctor
|{uri-maven-artifact-query}[asciidoctorj]
|{uri-maven-artifact-detail}[{artifact-version}]
|{uri-maven-artifact-file}.pom[pom] {uri-maven-artifact-file}.jar[jar] {uri-maven-artifact-file}-javadoc.jar[javadoc (jar)] {uri-maven-artifact-file}-sources.jar[sources (jar)] {uri-maven-artifact-file}-bin.zip[distribution (zip)]

|org.asciidoctor
|{uri-maven-artifact-api-query}[asciidoctorj-api]
|{uri-maven-artifact-api-detail}[{artifact-version}]
|{uri-maven-artifact-api-file}.pom[pom] {uri-maven-artifact-api-file}.jar[jar] {uri-maven-artifact-api-file}-javadoc.jar[javadoc (jar)] {uri-maven-artifact-api-file}-sources.jar[sources (jar)]

|org.asciidoctor
|asciidoctorj-epub3
|1.5.0-alpha.9
|{empty}

|org.asciidoctor
|asciidoctorj-pdf
|1.5.0-alpha.18
|{empty}
|===

CAUTION: The artifactId changed to `asciidoctorj` starting in 1.5.0.

== Installation

To start using AsciidoctorJ, you need to add the required dependency to the dependency management system of your choice, Maven, Gradle or Apache Ivy.
If you don't use a Dependency Management system please check the dependency graph and add all jars in it to your classpath.

// SW: Need functional tests for a java maven project and a java gradle project

[source,xml]
[subs=""specialcharacters,attributes,callouts""]
.Declaring the dependency in a Maven build file (i.e., pom.xml)
----
<dependencies>
  <dependency>
    <groupId>org.asciidoctor</groupId>
    <artifactId>asciidoctorj</artifactId>
    <version>{artifact-version}</version> <!--1-->
  </dependency>
</dependencies>
----

[source,groovy]
[subs=""specialcharacters,attributes,callouts""]
.Declaring the dependency in a Gradle build file (e.g., build.gradle)
----
dependencies {
  compile 'org.asciidoctor:asciidoctorj:{artifact-version}'
}
----

[source,scala]
[subs=""specialcharacters,attributes,callouts""]
.Declaring the dependency in an SBT build file (e.g., build.sbt)
----
libraryDependencies += ""org.asciidoctor"" % ""asciidoctorj"" % ""{artifact-version}"" // <1>
----

<1> Specifying the version of AsciidoctorJ implicitly selects the version of Asciidoctor

[source,clojure]
[subs=""specialcharacters,attributes,callouts""]
.Declaring the dependency in a Leiningen build file (e.g., project.clj)
----
:dependencies [[org.asciidoctor/asciidoctorj ""{artifact-version}""]]
----

// DA: Should we mention how to download if you just want to use the asciidoctorj command?

[TIP]
====
In addition to using AsciidoctorJ directly, you can invoke it as part of your build using the Maven or Gradle plugin.

- {uri-maven-guide}[How to Install and Use the Asciidoctor Maven Plugin]
- {uri-gradle-guide}[How to Install and Use the Asciidoctor Gradle Plugin]
====

[NOTE]
The versions of Asciidoctor and AsciidoctorJ no longer align since version 1.6.0 of AsciidoctorJ.
Please check the corresponding release notes to find out which version of Asciidoctor is packaged if you are embedding the library.
If you use the distribution you can call `asciidoctorj --version` to get the version of Asciidoctor that is embedded in AsciidoctorJ.


=== Windows Installation

A {uri-chocolatey}[Chocolatey] package is available which installs the
asciidoctorj-{artifact-version}-bin.zip Bintray artifact along with a
binary shim in %ChocolateyInstall%\\bin which lets you run AsciidoctorJ
from the command line.

----
C:\\> choco install asciidoctorj
C:\\> where asciidoctorj
C:\\ProgramData\\chocolatey\\bin\\asciidoctorj.exe
C:\\> asciidoctorj -b pdf README.adoc
----

== Converting documents

The main entry point for AsciidoctorJ is the `Asciidoctor` Java interface.
This interface provides four methods for converting AsciiDoc content.

* `convert`
* `convertFile`
* `convertFiles`
* `convertDirectory`

You'll learn about these methods in the <<converting-documents,converting documents section>>.

IMPORTANT: Prior to Asciidoctor 1.5.0, the term `render` was used in these method names instead of `convert` (i.e., `render`, `renderFile`, `renderFiles` and `renderDirectory`).
AsciidoctorJ continues to support the old method names for backwards compatibility.

[cols=""1m,1m,2""]
.Convert methods on the `Asciidoctor` interface
|===
|Method Name |Return Type| Description

|convert
|String
|Parses AsciiDoc content read from a string or stream and converts it to the format specified by the `backend` option.

|convertFile
|String
|Parses AsciiDoc content read from a file and converts it to the format specified by the `backend` option.

|convertFiles
|String[]
|Parses a collection of AsciiDoc files and converts them to the format specified by the `backend` option.

|convertDirectory
|String[]
|Parses all AsciiDoc files found in the specified directory (using the provided strategy) and converts them to the format specified by the `backend` option.
|===

// What is the 'provided strategy', need a link

NOTE: All the methods listed in Table 3 are overloaded to accommodate various input types and options.

You retrieve an instance of the `Asciidoctor` interface from the factory method provided.

[source]
.Creating an Asciidoctor instance from Asciidoctor.Factory
----
import static org.asciidoctor.Asciidoctor.Factory.create;
import org.asciidoctor.Asciidoctor;

Asciidoctor asciidoctor = create();
----

Once you retrieve an instance of the `Asciidoctor` interface, you can use it to convert AsciiDoc content.
Here's an example of using AsciidoctorJ to convert an AsciiDoc string.

NOTE: The following `convertFile` or `convertFiles` methods will only return a converted `String` object or array if you disable writing to a file, which is enabled by default.
To disable writing to a file, create a new `Options` object, disable the option to create a new file with `option.setToFile(false)`, and then pass the object as a parameter to `convertFile` or `convertFiles`.

[source]
.Converting an AsciiDoc string
----
//...
import java.util.HashMap;
//...

String html = asciidoctor.convert(
    ""Writing AsciiDoc is _easy_!"",
    new HashMap<String, Object>());
System.out.println(html);
----

The `convertFile` method will convert the contents of an AsciiDoc file.

[source]
.Converting an AsciiDoc file
----
//...
import java.util.HashMap;
//...

String html = asciidoctor.convertFile(
    new File(""sample.adoc""),
    new HashMap<String, Object>());
System.out.println(html);
----

The `convertFiles` method will convert a collection of AsciiDoc files:

[source]
.Converting a collection of AsciiDoc files
----
//...
import java.util.Arrays;
//...

String[] result = asciidoctor.convertFiles(
    Arrays.asList(new File(""sample.adoc"")),
    new HashMap<String, Object>());

for (String html : result) {
    System.out.println(html);
}
----

WARNING: If the converted content is written to files, the `convertFiles` method will return a String Array (i.e., `String[]`) with the names of all the converted documents.

Another method provided by the `Asciidoctor` interface is `convertDirectory`.
This method converts all of the files with AsciiDoc extensions (`.adoc` _(preferred)_, `.ad`, `.asciidoc`, `.asc`) that are present within a specified folder and following given strategy.

An instance of the `DirectoryWalker` interface, which provides a strategy for locating files to process, must be passed as the first parameter of the `convertDirectory` method.
Currently `Asciidoctor` provides two built-in implementations of the `DirectoryWalker` interface:

[cols=""1m,2""]
.Built-in `DirectoryWalker` implementations
|===
|Class |Description

|AsciiDocDirectoryWalker
|Converts all files of given folder and all its subfolders. Ignores files starting with underscore (_).

|GlobDirectoryWalker
|Converts all files of given folder following a glob expression.
|===

If the converted content is not written into files, `convertDirectory` will return an array listing all the documents converted.

// SW: Maybe provide an example of this array output?

[source]
.Converting all AsciiDoc files in a directory
----
//...
import org.asciidoctor.AsciiDocDirectoryWalker;
//...

String[] result = asciidoctor.convertDirectory(
    new AsciiDocDirectoryWalker(""src/asciidoc""),
    new HashMap<String, Object>());

for (String html : result) {
    System.out.println(html);
}
----

Another way to convert AsciiDoc content is by calling the `convert` method and providing a standard Java `java.io.Reader` and `java.io.Writer`.
The `Reader` interface is used as the source, and the converted content is written to the `Writer` interface.

[source]
.Converting content read from a java.io.Reader to a java.io.Writer
----
//...
import java.io.FileReader;
import java.io.StringWriter;
//...

FileReader reader = new FileReader(new File(""sample.adoc""));
StringWriter writer = new StringWriter();

asciidoctor.convert(reader, writer, options().asMap());

StringBuffer htmlBuffer = writer.getBuffer();
System.out.println(htmlBuffer.toString());
----

=== Safe mode and file system access
Asciidoctor provides security levels that control the read and write access of attributes, the include directive, macros, and scripts while a document is processing. Each level includes the restrictions enabled in the prior security level.

When Asciidoctor (and AsciidoctorJ) is used as _API_, it uses `SECURE` safe mode by default.
This mode is the most restrictive one and in summary it disallows the document from attempting to read files from the file system and including their contents into the document.

We recommend you to set `SAFE` safe mode when rendering AsciiDoc documents using AsciidoctorJ to have almost all Asciidoctor features such as _icons_, _include directive_ or retrieving content from _URIs_ enabled.

Safe mode is set as option when a document is rendered.
For example:

[source, java]
----
import static org.asciidoctor.OptionsBuilder.options;

Map<String, Object> options = options().safe(SafeMode.SAFE)
                                       .asMap();

String outfile = asciidoctor.convertFile(new File(""sample.adoc""), options);
----

We are going to explain in more detail options in <<conversion-options, next section>>.


You can read more about safe modes in http://asciidoctor.org/docs/user-manual/#running-asciidoctor-securely

=== Conversion options

Asciidoctor supports numerous options, such as:

`in_place`::
  Converts the output to a file adjacent to the input file.

`template_dirs`::
  Specifies a directory of {uri-tilt}[Tilt]-compatible templates to be used instead of the default built-in templates

`attributes`::
  A Hash (key-value pairs) of attributes to configure various aspects of the AsciiDoc processor

The second parameter of the `convert` method is `java.util.Map`.
The options listed above can be set in `java.util.Map`.

[source]
.Using the `in_place` option and the `backend` attribute
----
Map<String, Object> attributes = new HashMap<String, Object>();
attributes.put(""backend"", ""docbook""); // <1>

Map<String, Object> options = new HashMap<String, Object>();
options.put(""attributes"", attributes); // <2>
options.put(""in_place"", true); // <3>

String outfile = asciidoctor.convertFile(new File(""sample.adoc""), options);
----
<1> Defines the `backend` attribute as `docbook` in the attributes map
<2> Registers the attributes map as the `attributes` option in the options map
<3> Defines the `in_place` option in the options map

Another way for setting options is by using `org.asciidoctor.Options` class.
`Options` is a simple Java class which contains methods for setting required options.
Note that related with `org.asciidoctor.Options` class, there is `org.asciidoctor.Attributes` class, which can be used for setting attributes.

The `convert` method is overloaded so `org.asciidoctor.Options` can be passed instead of a `java.util.Map`.

[source]
.Using the in_place option and the backend attribute
----
Attributes attributes = new Attributes();
attributes.setBackend(""docbook""); // <1>

Options options = new Options();
options.setAttributes(attributes); // <2>
options.setInPlace(true); // <3>

String outfile = asciidoctor.convertFile(new File(""sample.adoc""), options);
----
<1> Defines the `backend` attribute as `docbook` in the attributes class
<2> Registers the attributes class as the `attributes` option in the options class
<3> Defines the `in_place` option in the options class

AsciidoctorJ also provides two builder classes to create these maps and classes in a more readable form.

`AttributesBuilder`::
  Used to define attributes with a fluent API

`OptionsBuilder`::
  Used to define options with a fluent API

The code below results in the same output as the previous example but uses the builder classes.

[source]
.Setting attributes and options with the builder classes
----
import static org.asciidoctor.AttributesBuilder.attributes;
import static org.asciidoctor.OptionsBuilder.options;

//...
Map<String, Object> attributes = attributes().backend(""docbook"") // <1>
                                             .asMap();

Map<String, Object> options = options().inPlace(true)
                                       .attributes(attributes) // <2>
                                       .asMap(); // <3>

String outfile = asciidoctor.convertFile(new File(""sample.adoc""), options);
----
<1> Defines the `backend` attribute as `docbook` using fluent API.
<2> Registers the attributes map as `attributes`.
<3> Converts options to `java.util.Map` instance.

[source]
.Setting attributes and options with the builder classes
----
import static org.asciidoctor.AttributesBuilder.attributes;
import static org.asciidoctor.OptionsBuilder.options;

//...
Attributes attributes = attributes().backend(""docbook"").get(); // <1>
Options options = options().inPlace(true).attributes(attributes).get(); // <2>

String outfile = asciidoctor.convertFile(new File(""sample.adoc""), options); // <3>
----
<1> Defines and returns an `Attributes` class instead of `java.util.Map` by calling `get()` method instead of `asMap()`.
<2> Defines and returns an `Options` class instead of `java.util.Map` by calling `get()` method instead of `asMap()`.
<3> Converts the document passing `Options` class.

TIP: All methods used to convert content are overloaded with `OptionsBuilder` parameter, so it is no longer required to call `get` nor `asMap` methods.

WARNING: The `icons` attribute requires a `String` to set the value used to “draw” icons.
At this time, you can use two constants `org.asciidoctor.Attributes.IMAGE_ICONS` for using the same approach as AsciiDoc, that is using `img` tags, or `org.asciidoctor.Attributes.FONT_ICONS` for using icons from {uri-font-awesome}[Font Awesome^].

Attributes can be specified as `String` or `Array` instead of pair key/value by using `org.asciidoctor.Attributes.setAttributes(String)` or [x-]`org.asciidoctor.Attributes.setAttributes(String...)` and `AttributesBuilder` methods.

[source]
.Passing attributes as a string
----
//...
Attributes attributes = attributes().attributes(""toc numbered"").get();
Options options = options().attributes(attributes).get();
----

Passing attributes as a string is equivalent to passing individual attributes.

[source]
.Passing individual attributes
----
//...
Attributes attributes = attributes().tableOfContents(true).sectionNumbers(true).get();
Options options = options().attributes(attributes).get();
----

You can also use an array.

[source]
.Passing attributes as an array
----
//...
String[] attributesArray = new String[]{""toc"", ""source-highlighter=coderay""};
Attributes attributes = attributes().attributes(attributesArray).sectionNumbers(true).get();
Options options = options().attributes(attributes).get();
----

Passing attributes as an array is equivalent to passing individual attribute.

[source]
.Passing individual attributes
----
//...
Attributes attributes = attributes().tableOfContents(true).sectionNumbers(true).sourceHighlighter(""coderay"").get();
Options options = options().attributes(attributes).get();
----

== Locating files

A utility class `AsciiDocDirectoryWalker` is available for searching the AsciiDoc files present in a root folder and its subfolders.
`AsciiDocDirectoryWalker` locates all files that end with `.adoc`, `.ad`, `.asciidoc` or `.asc`.
Also it ignores all files starting with underscore (`_`).

[source]
.Locating AsciiDoc files with `AsciiDocDirectoryWalker`
----
import java.util.List;
import org.asciidoctor.AsciiDocDirectoryWalker;

DirectoryWalker directoryWalker = new AsciiDocDirectoryWalker(""docs""); // <1>
List<File> asciidocFiles = directoryWalker.scan(); // <2>
----
<1> Defines which parent directory is used for searching.
<2> Returns a list of all AsciiDoc files found in root folder and its subfolders.

A utility class `GlobDirectoryWalker` is available for searching the AsciiDoc files present in a root folder and scanning using a `Glob` expression.
`GlobDirectoryWalker` locates all files that end with `.adoc`, `.ad`, `.asciidoc` or `.asc`.

[source]
.Locating AsciiDoc files with `GlobDirectoryWalker`
----
import java.util.List;
import org.asciidoctor.GlobDirectoryWalker;

DirectoryWalker directoryWalker = new GlobDirectoryWalker(""docs"", ""**/*.adoc""); // <1>
List<File> asciidocFiles = directoryWalker.scan(); // <2>
----
<1> Defines which parent directory is used for searching and the glob expression.
<2> Returns a list of all AsciiDoc files matching given glob expression.

== Reading the document tree

Instead of converting an AsciiDoc document, you may want to parse the document to read information it contains or navigate the document's structure.
AsciidoctorJ let's you do this!

AsciidoctorJ provides a model of the abstract syntax tree of the document.
These objects are directly linked to the internal representation.

To load a document, use the `load` or `loadFile` methods.

[source]
----
import org.asciidoctor.ast.Document;

//...

Document document = asciidoctor.load(DOCUMENT, new HashMap<String, Object>()); // <1>
assertThat(document.doctitle(), is(""Document Title"")); // <2>
----
<1> Document from a String is loaded into `Document` object.
<2> Title of the document is retrieved.

But also all blocks that conforms the document can be retrieved.
Currently there are support for three kinds of blocks.
`Blocks` itself, `Section` for sections of the document and `StructuralNode` which is the base type where all kind of blocks (including those not mapped as Java class) are mapped.

[source]
----
import org.asciidoctor.ast.Document;
import org.asciidoctor.ast.Section;

//...

Document document = asciidoctor.load(DOCUMENT, new HashMap<String, Object>()); // <1>
Section section = (Section) document.blocks().get(1); // <2>

assertThat(section.index(), is(0)); // <3>
assertThat(section.sectname(), is(""sect1""));
assertThat(section.special(), is(false));
----
<1> Document from a String is loaded into `Document` object.
<2> All blocks are get and because in this example the first block is a Section block, we cast it directly.
<3> Concrete methods for sections can be called.

Blocks can also be retrieved from query using `findBy` method.

[source]
----
Document document = asciidoctor.load(DOCUMENT, new HashMap<String, Object>());
Map<Object, Object> selector = new HashMap<>(); // <1>
selector.put(""context"", "":image""); // <2>

List<StructuralNode> findBy = document.findBy(selector);
assertThat(findBy, hasSize(2)); //<3>
----
<1> To make queries you need to use a `map` approach. Currently this is because of the Asciidoctor API but it will change in near future.
<2> In this example all blocks with context as image is returned. Notice that the colon (`:`) must be added in the value part.
<3> Document used as example contains two images.

== Extension API

[NOTE]
If you are migrating existing extensions to a newer version of AsciidoctorJ please read the <<docs/extension-migration-guide#,Extension Migration Guide>>

One of the major improvements to Asciidoctor recently is the extensions API.
AsciidoctorJ brings this extension API to the JVM environment.
{uri-repo}[AsciidoctorJ] allows us to write extensions in Java instead of Ruby.

Asciidoctor provides seven types of extension points.
Each extension point has an abstract class in Java that maps to the extension API in Ruby.

[cols=""1m,2""]
.AsciidoctorJ extension APIs
|===
|Name |Class

|Preprocessor
|org.asciidoctor.extension.Preprocessor

|Treeprocessor
|org.asciidoctor.extension.Treeprocessor

|Postprocessor
|org.asciidoctor.extension.Postprocessor

|Block processor
|org.asciidoctor.extension.BlockProcessor

|Block macro processor
|org.asciidoctor.extension.BlockMacroProcessor

|Inline macro processor
|org.asciidoctor.extension.InlineMacroProcessor

|Include processor
|org.asciidoctor.extension.IncludeProcessor
|===

You can read more about the Extension API in the <<docs/integrator-guide#,Integrator Guide>>.

=== Ruby extensions

You can even register extensions written in Ruby using AsciidoctorJ.
To register a _Ruby_ extension you must get a `RubyExtensionRegistry` class instead of `JavaExtensionRegistry`.

[source]
.Register a Ruby extension in Java
----
RubyExtensionRegistry rubyExtensionRegistry = this.asciidoctor.rubyExtensionRegistry(); // <1>
rubyExtensionRegistry.loadClass(Class.class.getResourceAsStream(""/YellRubyBlock.rb"")).block(""rubyyell"", ""YellRubyBlock""); // <2>

String content = asciidoctor.convertFile(new File(
                ""target/test-classes/sample-with-ruby-yell-block.ad""),
                options().toFile(false).get());
----
<1> `rubyExtensionRegistry` method is called to get a rubyExtensionRegistry instance.
<2> Ruby file containing a class implementing a Block extension is loaded inside the Ruby runtime. Then the block is registered with a name (rubyyell), and we pass the name of the class to be instantiated.

[source,ruby]
.YellBlock.rb
----
require 'asciidoctor'
require 'asciidoctor/extensions'

class YellRubyBlock < Asciidoctor::Extensions::BlockProcessor
  option :contexts, [:paragraph]
  option :content_model, :simple

  def process parent, reader, attributes
    lines = reader.lines.map {|line| line.upcase.gsub(/\\.( |$)/, '!\\\\1') }
    Asciidoctor::Block.new parent, :paragraph, :source => lines, :attributes => attributes
  end
end
----

== Logs handling API

[NOTE]
====
This API is inspired by Java Logging API (JUL).
If you are familiar with `java.util.logging.*` you will see familiar analogies with some of its components.
====

AsciidoctorJ (v1.5.7+) offers the possibility to capture messages generated during document rendering.
These messages correspond to logging information and are organized in 6 severity levels:

. DEBUG
. INFO
. WARN
. ERROR
. FATAL
. UNKNOWN

The easiest way to capture messages is registering a `LogHandler` through the `Asciidoctor` instance.

[source,java]
.Registering a LogHandler
----
Asciidoctor asciidoctor = Asciidoctor.Factory.create();

asciidoctor.registerLogHandler(new LogHandler() { // <1>
    @Override
    public void log(LogRecord logRecord) {
        System.out.println(logRecord.getMessage());
    }
});
----
<1> Use `registerLogHandler` to register one or more handlers.

The `log` method in the `org.asciidoctor.log.LogHandler` interface provides a `org.asciidoctor.log.LogRecord` that exposes the following information:

[horizontal]
Severity severity::
Severity level of the current record.

Cursor cursor::
Information about the location of the event, contains:
* LineNumber: relative to the file where the message occurred.
* Path: source file simple name, or `<stdin>` value when converting from a String.
* Dir: absolute path to the source file parent directory, or the execution path when converting from a String.
* File: absolute path to the source file, or `null` when converting from a String. +
These will point to the correct source file, even when this is included from another.

String message::
Descriptive message about the event.

String sourceFileName::
Contains the value `<script>`. +
For the source filename see `Cursor` above.

String sourceMethodName::
The Asciidoctor Ruby engine method used to convert the file; `convertFile` or `convert` whether you are converting a File or a String.

=== Logs Handling SPI

Similarly to AsciidoctorJ extensions, the Log Handling API provides an alternate method to register Handlers without accessing `Asciidoctor` instance.

Start creating a normal LogHandler implementation.

[source,Java]
----
package my.asciidoctor.log.MemoryLogHandler;

import java.util.ArrayList;
import java.util.List;
import org.asciidoctor.log.LogHandler;
import org.asciidoctor.log.LogRecord;

/**
 * Stores LogRecords in memory for later analysis.
 */
public class MemoryLogHandler extends LogHandler {

  private List<LogRecord> logRecords = new ArrayList<>();

  @Override
  public void log(LogRecord logRecord) {
    logRecords.add(record);
  }

  public List<LogRecord> getLogRecords() {
    return logRecords;
  }
}
----

Next, create a file called `org.asciidoctor.log.LogHandler` inside `META-INF/services` with the implementation’s full qualified name.

.META-INF/services/org.asciidoctor.log.LogHandler
 my.asciidoctor.log.MemoryLogHandler

And that’s all.
Now when a .jar file containing the previous structure is dropped inside classpath of AsciidoctorJ, the handler will be registered automatically.

== Converting to EPUB3

The Asciidoctor EPUB3 gem (asciidoctor-epub3) is bundled inside the AsciidoctorJ EPUB3 jar (asciidoctorj-epub3).
To use it, simply add the asciidoctorj-epub3 jar to your dependencies.
The version of the AsciidoctorJ EPUB3 jar aligns with the version of the Asciidoctor EPUB3 gem.

Here's how you can add the AsciidoctorJ EPUB3 jar to your Maven dependencies:

[source,xml]
----
<dependencies>
  <dependency>
    <groupId>org.asciidoctor</groupId>
    <artifactId>asciidoctorj-epub3</artifactId>
    <version>1.5.0-alpha.4</version>
    <scope>runtime</scope>
  </dependency>
</dependencies>
----

Once you've added the AsciidoctorJ EPUB3 jar to your classpath, you can set the `backend` attribute to `epub3`.
The document will be converted to the http://idpf.org/epub/30[EPUB3^] format.

CAUTION: The [app]_asciidoctor-epub3_ gem is alpha.
While it can be used successfully, there may be bugs and its functionality may change in incompatible ways before the first stable release.
In other words, by using it, you are also testing it ;)

Let's see an example of how to use AsciidoctorJ with the EPUB3 converter.

[source,asciidoc]
.spine.adoc
----
= Book Title
Author Name
:imagesdir: images <1>

include::content-document.adoc[] <2>
----
<1> The EPUB3 converter requires the value of the `imagesdir` attribute to be `images`.
<2> The EPUB3 converter must be run on a _spine_ document that has at least one include directive (and no other body content) in order to function properly.

[source,asciidoc]
.content-document.adoc
----
= Content Title
Author Name

[abstract]
This is the actual content.

== First Section

And off we go.
----

And finally we can convert the document to EPUB3 using AsciidoctorJ.

[source]
----
asciidoctor.convertFile(new File(""spine.adoc""),
                options().safe(SafeMode.SAFE).backend(""epub3"").get()); // <1> <2>

assertThat(new File(""target/test-classes/index.epub"").exists(), is(true));
----
<1> Currently, the EPUB3 converter must be run in `SAFE` or `UNSAFE` mode due to a bug
<2> `epub3` is the name of the backend that must be set to convert to EPUB3.

// TODO document how to convert to KF8/MOBI (need to set KINDLEGEN environment variable)
// TODO add section that covers using Asciidoctor PDF via the AsciidoctorJ PDF jar


== Writing a custom converter

For output formats that are not natively supported by Asciidoctor it is possible to write an own converter in Java.
You can find out more about how to write your own converters using AsciidoctorJ in the <<docs/integrator-guide.adoc#publish-everywhere-adapt-asciidoctor-to-your-own-target-format,Integrator Guide>>.

== Loading Ruby libraries

Simple extensions may be fully implemented in Java, but if you want to create complex extensions you can mix Ruby and Java code.
This means that you may need to execute a Ruby file or a RubyGem (i.e., gem) inside your extension.

To load a Ruby file inside the Ruby runtime, you can use `org.asciidoctor.internal.RubyUtils.loadRubyClass(Ruby, InputStream)`.
You can also load a gem using an API that wraps Ruby's `require` command.
The gem must be available inside the classpath.
Next run `org.asciidoctor.internal.RubyUtils.requireLibrary(Ruby, String)`, passing the name of the gem as the second argument.

// SW or AS: show an example of loading Ruby libraries or point to an external resource showing examples/further documentation.

== JRuby instance

Sometimes you may need the Ruby runtime used inside AsciidoctorJ.
One reason is because you are using JRuby outside AsciidoctorJ and you want to reuse the same instance.
Another reason is that you need to instantiate by yourself an Asciidoctor Ruby object.

To get this instance you can use `org.asciidoctor.internal.JRubyRuntimeContext.get(Asciidoctor)` to get it from a given Asciidoctor instance.

== GEM_PATH

By default, AsciidoctorJ comes with all required gems bundled within the jar.
But in some circumstances like OSGi environments you may require to store gems in an external folder and be loaded by AsciidoctorJ.
To accomplish this scenario, `create` method provides a parameter to set folder where gems are present.
Internally, AsciidoctorJ will set `GEM_PATH` environment variable to given path.

[source]
.Example of setting GEM_PATH
----
import static org.asciidoctor.Asciidoctor.Factory.create;
import org.asciidoctor.Asciidoctor;

Asciidoctor asciidoctor = create(""/my/gem/path""); // <1>
----
<1> Creates an `Asciidoctor` instance with given `GEM_PATH` location.

== Using AsciidoctorJ in an OSGi environment

In a non OSGi context, the following snippet will successfully create an Asciidoctor object:

[source,java]
----
import static org.asciidoctor.Asciidoctor.Factory.create;
import org.asciidoctor.Asciidoctor;

Asciidoctor asciidoctor = create();
----

In an OSGi context it will not work because JRuby needs some paths to find the Asciidoctor gems. In order to make it work, you will need to specify the Asciidoctor gems path using the JavaEmbedUtils class. We will update the previous snippet of code to specify this path:

[source,java]
----
import static org.asciidoctor.Asciidoctor.Factory.create;
import org.asciidoctor.Asciidoctor;

Asciidoctor asciidoctor = create(Arrays.asList(""uri:classloader:/gems/asciidoctor-1.5.8/lib"")); <1><2>
----
<1> `uri:classloader:/gems/asciidoctor-<version>/lib` specifies where the gems for Asciidoctor are located. Actually this path is located inside the `asciidoctorj-<version>.jar` file
<2> The version here differs from the AsciidoctorJ version as it corresponds to the version of Asciidoctor, not the AsciidoctorJ one.

[NOTE]
We consider this code to be placed inside an OSGi bundle

This solution has pros and cons:

* _Pros:_ you don't need to extract the gems located in the asciidoctorj binary ;
* _Cons:_
** the version of asciidoctor is hard coded ;

== Optimization

JRuby may start slower than expected versus the C-based Ruby implementation (MRI).
Fortunately, JRuby offers flags that can improve the start time and tune applications.
Several Java flags can also be used in conjunction with or apart from the JRuby flags in order to improve the start time even more.

// SW: Need examples of JRuby and Java flags being used

For small tasks such as converting an AsciiDoc document, two JRuby flags can drastically improve the start time:

[cols=""1m,2"", width=""50%""]
.JRuby flags
|===
|Name |Value

|jruby.compat.version
|RUBY1_9

|jruby.compile.mode
|OFF
|===

When using AsciidoctorJ via the API these flags have to be set as system properties when creating the `org.asciidoctor.Asciidoctor` instance:

[source,java]
----
System.setProperty(""jruby.compat.version"", ""RUBY1_9"");
System.setProperty(""jruby.compile.mode"", ""OFF"");
Asciidoctor asciidoctor = Asciidoctor.Factory.create();
----

When starting AsciidoctorJ via the CLI these options can be defined in the files `.jrubyrc` that are loaded from the current working directory and the home directory of the user.

----
$ cat ./.jrubyrc
compat.version=RUBY1_9
compile.mode=OFF
$ ./asciidoctorj -V
AsciidoctorJ 1.5.2 [http://asciidoctor.org]
Runtime Environment: jruby 1.7.20 (1.9.3)
----

[NOTE]
The properties in these `.jrubyrc` files do not contain the prefix `jruby.`. 
The property values also must not have trailing blanks!

Alternatively you can also set any system properties using the environment variable `ASCIIDOCTORJ_OPTS`:

----
$ export ASCIIDOCTORJ_OPTS=-Djruby.compat.version=RUBY1_9
$ asciidoctorj -V
AsciidoctorJ 1.5.2 [http://asciidoctor.org]
Runtime Environment: jruby 1.7.20 (1.9.3)
----

The Java flags available for improving start time depend on whether your working on a 32- or 64-bit processor and your JDK version.
Let's see a summary of these flags and in which environments they can be used.

[cols=""1m,2"",width=""75%""]
.Java flags
|===
|Name |JDK

|-client
|32 bit Java

|-Xverify:none
|32/64 bit Java

|-XX:+TieredCompilation
|32/64 bit Java SE 7

|-XX:TieredStopAtLevel=1
|32/64 bit Java SE 7
|===

[source,shell]
.Setting flags for Java SE 6
----
export JAVA_OPTS=""-Xverify:none -client"" 
----

You can find a full explanation on how to improve the start time of JRuby applications in <<Optimization>>.

== Running AsciidoctorJ on WildFly

If you want to use AsciidoctorJ in an application deployed on [app]_WildFly_, you have to follow the instruction below:

. Create an *Asciidoctor module* for [app]_WildFly_.
. Create the following folder tree: [path]_$JBOSS_HOME/modules/org/asciidoctor/main_.
. Create the module descriptor file [path]_module.xml_.
+
[subs=""+attributes""]
[source,xml]
.Asciidoctor module descriptor for WildFly
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<module xmlns=""urn:jboss:module:1.0"" name=""org.asciidoctor"">
    <resources>
        <resource-root path=""asciidoctorj-api-{artifact-version}.jar""/>
        <resource-root path=""asciidoctorj-{artifact-version}.jar""/>
        <resource-root path=""jcommander-1.72.jar""/>
        <resource-root path=""jruby-complete-9.2.7.0.jar""/>
    </resources>
    <dependencies>
        <module name=""sun.jdk"" export=""true"">
            <imports>
                <include path=""sun/misc/Unsafe"" />
            </imports>
        </module>
        <module name=""javax.management.j2ee.api""/>
        <module name=""javax.api""/>
        <module name=""org.slf4j""/>
    </dependencies>
</module>
----
. Copy the jar files into the same folder as the _module.xml_ file.
. Make sure the version numbers of the jar files agree with what's in the current set.
Restart WildFly for the new module to take effect.


. Add a dependency on your Java archive to this WildFly module using one of the following options:
.. Add the dependency just into the [path]_MANIFEST.MF_ file.
+
.MANIFEST.MF file example with dependency to Asciidoctor module
----
Manifest-Version: 1.0
Dependencies: org.asciidoctor
...
----

.. _Or_, configure the dependency into the [path]_pom.xml_ with the [app]_Maven JAR/WAR plugin_.
+
[source,xml]
[subs=""specialcharacters,attributes,callouts""]
.pom.xml file example with Maven WAR plugin configuration to add a dependency
----
...
<dependencies>
  <dependency>
    <groupId>org.asciidoctor</groupId>
    <artifactId>asciidoctorj</artifactId>
    <version>{artifact-version}</version>
    <scope>provided</scope> <!--1-->
    ...
  </dependency>
</dependencies>
...
<plugin>
  <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-war-plugin</artifactId>
    <version>2.4</version>
    <configuration>
      <archive>
        <manifestEntries>
          <Dependencies>org.asciidoctor</Dependencies> <!--2-->
        </manifestEntries>
      </archive>
    </configuration>
</plugin>
...
----
<1> The AsciidoctorJ dependency and the transitives dependencies don't need to be added to the final WAR since all JARs are available through the module.
<2> The module dependency will be added to the [path]_MANIFEST.MF_ file.

== Using a pre-release version

Pre-release versions of `AsciidoctorJ` are published to Bintray.
You can find them in https://bintray.com/asciidoctor/maven/asciidoctorj/view.
Final releases are released to both Maven Central and Bintray.

Here's how to use a pre-release version in Maven:

[source, xml]
----
<repositories>
  <repository>
    <id>central</id>
    <name>bintray</name>
    <url>http://dl.bintray.com/asciidoctor/maven</url>
    <snapshots>
      <enabled>false</enabled>
    </snapshots>
  </repository>
</repositories>
----

== Using a snapshot version

Snapshot versions will be published to https://oss.jfrog.org.
To use a snapshot version of the the AsciidoctorJ library add this repository to your project:

[source,xml]
----
<repositories>
  <repository>
    <id>oss-jfrog-artifactory</id>
    <name>oss-jfrog-artifactory-releases</name>
    <url>https://oss.jfrog.org/artifactory/oss-snapshot-local</url>
    <snapshots>
      <enabled>true</enabled>
    </snapshots>
  </repository>
</repositories>
----

If you build your project using {uri-gradle}[Gradle] add the repository like this to your build:

[source,groovy]
----
repositories {
    maven {
        url 'http://oss.jfrog.org/oss-snapshot-local/'
    }
}
----


You can also download a snapshot version of the distribution from here: https://oss.jfrog.org/oss-snapshot-local/org/asciidoctor/asciidoctorj-distribution

== Development

AsciidoctorJ is built using {uri-gradle}[Gradle].
The project is structured as a multi-module build.

=== Project layout

The root folder is the root project and there are several subproject folders, each prefixed with _asciidoctorj-_.
Each subproject produces a primary artifact (e.g., jar or zip) and its supporting artifacts (e.g., javadoc, sources, etc).

The subprojects are as follows:

asciidoctorj-api::
  The common API for AsciidoctorJ.
  Other implementations for different platforms than JRuby may reuse and implement this API.
  Produces the asciidoctorj-api.jar

asciidoctorj::
  The main Java bindings for the Asciidoctor RubyGem (asciidoctor) running on JRuby.
  Also bundles optional RubyGems needed at runtime, such as coderay, tilt, haml and slim.
  Produces the asciidoctorj jar.

asciidoctorj-distribution::
  Produces the distribution zip that provides the standalone `asciidoctorj` command.

asciidoctorj-epub3::
  Bundles the Asciidoctor EPUB3 RubyGem (asciidoctor-pdf) and its dependencies as the asciidoctorj-epub3 jar.

asciidoctorj-pdf::
  Bundles the Asciidoctor PDF RubyGem (asciidoctor-pdf) and its dependencies as the asciidoctorj-pdf jar.

asciidoctorj-diagram::
  Bundles the Asciidoctor Diagram RubyGem (asciidoctor-diagram) and its dependencies as the asciidoctorj-diagram jar.

asciidoctorj-arquillian-extension::
  Bundles an Arquillian extension that allows to inject an Asciidoctor instance or other instances commonly used by Asciidoctor tests into a test case.

asciidoctorj-test-support::
  Contains some common test classes that are used by multiple other subprojects and the Arquillian extension.

The Gradle build is partitioned into the following files:

....
build.gradle
gradle.properties
settings.gradle
gradle/
  wrapper/
    ...
  deploy.gradle
  deploySnapshot.gradle
  eclipse.gradle
  providedConfiguration.gradle
  publish.gradle
  sign.gradle
asciidoctorj-arquillian-extension/
  build.gradle
asciidoctorj-api/
  build.gradle
asciidoctorj-core/
  build.gradle
asciidoctorj-diagram/
  build.gradle
asciidoctorj-distribution/
  build.gradle
asciidoctorj-epub3/
  build.gradle
asciidoctorj-pdf/
  build.gradle
asciidoctorj-test-support/
  build.gradle
....

=== Build the project

You invoke Gradle on this project using the `gradlew` command (i.e., the Gradle Wrapper).

TIP: We strongly recommend that you use Gradle via the https://www.timroes.de/2013/09/12/speed-up-gradle[Gradle daemon].

To clone the project, compile the source and build the artifacts (i.e., jars) locally, run:

 $ git clone https://github.com/asciidoctor/asciidoctorj
   cd asciidoctorj
   ./gradlew assemble

You can find the built artifacts in the [path]_asciidoctorj-*/build/libs_ folders.

To execute tests when running the build, use:

 $ ./gradlew build

To only execute the tests, run:

 $ ./gradlew check

You can also run tests for a single module:

 $ cd asciidoctorj-core
   ../gradlew check

To run a single test in the asciidoctorj-core subproject, use:

 $ ../gradlew -Dsingle.test=NameOfTestClass test

To create the distribution, run:

 $ ./gradlew distZip

You can find the distribution in the [path]_asciidoctorj-distribution/build/distributions_ folder.

=== Develop in an IDE

==== IntelliJ IDEA

To import the project into IntelliJ IDEA 14, simply import the project using the import wizard.
For more information, see the https://www.jetbrains.com/idea/help/gradle.html[Gradle page] in the IntelliJ IDEA Web Help.

==== Eclipse

To open the project in Eclipse, first generate the Eclipse project files:

 $ cd asciidoctorj-core
   ./gradlew eclipse

Then, import the project into Eclipse using menu:File[Import,General,Existing Project into Workspace].

=== Continuous integration

Continuous integration for the AsciidoctorJ project is performed by Travis CI.
You can find recent build results, including the build status of pull requests, on the https://travis-ci.org/asciidoctor/asciidoctorj[asciidoctor/asciidoctorj] page.

=== Publish the artifacts

Artifacts are published to Maven Central and jCenter by way of Bintray's _Distribution as a Service_ platform.

Before publishing, you need to configure your gpg signing and Bintray credentials.
Create the file [path]_$HOME/.gradle/gradle.properties_ and populate the following properties.

----
signing.keyId=
signing.password=
signing.secretKeyRingFile=/home/YOUR_USERNAME/.gnupg/secring.gpg
bintrayUsername=
bintrayApiKey=
----

To build, assemble and sign the archives (jars and distribution zip), run:

 $ ./gradlew -PpublishRelease=true signJars

TIP: The `publishRelease=true` property is technically only required if the version is a snapshot.

To build, assemble (but not sign) and install the archives (jars and distribution zip) into the local Maven repository, run:

 $ ./gradlew -PpublishRelease=true install

To build, assemble, sign and publish the archives (jars and distribution zip) to Bintray, run:

 $ ./gradlew clean
   ./gradlew -i -x pMNPTML asciidoctorj-api:bintrayUpload asciidoctorj:bintrayUpload asciidoctorj-distribution:bintrayUpload

CAUTION: Don't run the `clean` task in the same execution as the `bintrayUpload` because it will not upload one of the signatures.

If you want to first perform a dry run of the upload, add the `dryRun=true` property.

 $ ./gradlew -i -PdryRun=true -x pMNPTML asciidoctorj-api:bintrayUpload asciidoctorj:bintrayUpload asciidoctorj-distribution:bintrayUpload

NOTE: The `-x pMNPTML` is necessary to work around a bug in the publishing plugin that prevents it from signing the archives.

IMPORTANT: Bintray does not allow you to publish snapshots.
You have to first update the version in [path]_gradle.properties_ to a release (or pre-release) version number.
Currently, Gradle is not configured to automatically tag a release, so *you have to create the git tag manually*.

=== Publish snapshot versions

To publish a snapshot version simply run:

 $ ./gradlew asciidoctorj-api:artifactoryPublish asciidoctorj:artifactoryPublish asciidoctorj-distribution:artifactoryPublish

This will publish the all artifacts that have a snapshot version number to https://oss.jfrog.org.

== Resources

The source code for AsciidoctorJ, including the latest developments and issues, can be found in the project's {uri-repo}[repository] on GitHub.
If you identify an issue while using AsciidoctorJ, please don't hesitate to {uri-issues}[file a bug report].
Also, don't forget to join the {uri-discuss}[Asciidoctor discussion list], where you can ask questions and leave comments.
",12491,False,1801.0406765666373,median
"/*

Copyright (c) 2007-2012, 2014-2020, Arvid Norberg
Copyright (c) 2016-2019, Steven Siloti
Copyright (c) 2016-2018, 2020, Alden Torres
Copyright (c) 2018, gubatron
Copyright (c) 2018, Xiyue Deng
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 author 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 ""libtorrent/config.hpp""

#if TORRENT_HAVE_MMAP || TORRENT_HAVE_MAP_VIEW_OF_FILE

#include ""libtorrent/mmap_storage.hpp""
#include ""libtorrent/mmap_disk_io.hpp""
#include ""libtorrent/disk_buffer_holder.hpp""
#include ""libtorrent/aux_/throw.hpp""
#include ""libtorrent/error_code.hpp""
#include ""libtorrent/error.hpp""
#include ""libtorrent/torrent_info.hpp""
#include ""libtorrent/aux_/disk_buffer_pool.hpp""
#include ""libtorrent/aux_/disk_io_job.hpp""
#include ""libtorrent/performance_counters.hpp""
#include ""libtorrent/debug.hpp""
#include ""libtorrent/units.hpp""
#include ""libtorrent/hasher.hpp""
#include ""libtorrent/aux_/disk_job_pool.hpp""
#include ""libtorrent/aux_/disk_io_thread_pool.hpp""
#include ""libtorrent/aux_/store_buffer.hpp""
#include ""libtorrent/aux_/time.hpp""
#include ""libtorrent/aux_/alloca.hpp""
#include ""libtorrent/aux_/array.hpp""
#include ""libtorrent/add_torrent_params.hpp""
#include ""libtorrent/aux_/merkle.hpp""
#include ""libtorrent/aux_/numeric_cast.hpp""
#include ""libtorrent/settings_pack.hpp""
#include ""libtorrent/aux_/file_view_pool.hpp""
#include ""libtorrent/aux_/scope_end.hpp""

#ifdef _WIN32
#include ""libtorrent/aux_/windows.hpp""
#include ""libtorrent/aux_/win_util.hpp""
#endif

#include <functional>
#include <condition_variable>

#include ""libtorrent/aux_/disable_warnings_push.hpp""
#include <boost/variant/get.hpp>
#include ""libtorrent/aux_/disable_warnings_pop.hpp""

#define DEBUG_DISK_THREAD 0

namespace libtorrent {
char const* job_name(aux::job_action_t job);
}

#if DEBUG_DISK_THREAD
#include <cstdarg> // for va_list
#include <sstream>
#include <cstdio> // for vsnprintf

#define DLOG(...) debug_log(__VA_ARGS__)
#else
#define DLOG(...) do {} while(false)
#endif

namespace libtorrent {
namespace {

#if DEBUG_DISK_THREAD

	void debug_log(char const* fmt, ...)
	{
		static std::mutex log_mutex;
		static const time_point start = clock_type::now();
		// map thread IDs to low numbers
		static std::unordered_map<std::thread::id, int> thread_ids;

		std::thread::id const self = std::this_thread::get_id();

		std::unique_lock<std::mutex> l(log_mutex);
		auto it = thread_ids.insert({self, int(thread_ids.size())}).first;

		va_list v;
		va_start(v, fmt);

		char usr[2048];
		int len = std::vsnprintf(usr, sizeof(usr), fmt, v);

		static bool prepend_time = true;
		if (!prepend_time)
		{
			prepend_time = (usr[len-1] == '\\n');
			fputs(usr, stderr);
			return;
		}
		va_end(v);
		char buf[2300];
		int const t = int(total_milliseconds(clock_type::now() - start));
		std::snprintf(buf, sizeof(buf), ""\\x1b[3%dm%05d: [%d] %s\\x1b[0m""
			, (it->second % 7) + 1, t, it->second, usr);
		prepend_time = (usr[len-1] == '\\n');
		fputs(buf, stderr);
	}

#endif // DEBUG_DISK_THREAD

	aux::open_mode_t file_flags_for_job(aux::disk_io_job* j)
	{
		aux::open_mode_t ret = aux::open_mode::read_only;
		if (!(j->flags & disk_interface::sequential_access)) ret |= aux::open_mode::random_access;
		return ret;
	}

	storage_index_t pop(std::vector<storage_index_t>& q)
	{
		TORRENT_ASSERT(!q.empty());
		storage_index_t const ret = q.back();
		q.pop_back();
		return ret;
	}
} // anonymous namespace

using jobqueue_t = tailqueue<aux::disk_io_job>;

// this is a singleton consisting of the thread and a queue
// of disk io jobs
struct TORRENT_EXTRA_EXPORT mmap_disk_io final
	: disk_interface
	, buffer_allocator_interface
{
	mmap_disk_io(io_context& ios, settings_interface const&, counters& cnt);
#if TORRENT_USE_ASSERTS
	~mmap_disk_io() override;
#endif

	void settings_updated() override;
	storage_holder new_torrent(storage_params const& params
		, std::shared_ptr<void> const& owner) override;
	void remove_torrent(storage_index_t) override;

	void abort(bool wait) override;

	void async_read(storage_index_t storage, peer_request const& r
		, std::function<void(disk_buffer_holder, storage_error const&)> handler
		, disk_job_flags_t flags = {}) override;
	bool async_write(storage_index_t storage, peer_request const& r
		, char const* buf, std::shared_ptr<disk_observer> o
		, std::function<void(storage_error const&)> handler
		, disk_job_flags_t flags = {}) override;
	void async_hash(storage_index_t storage, piece_index_t piece, span<sha256_hash> v2
		, disk_job_flags_t flags
		, std::function<void(piece_index_t, sha1_hash const&, storage_error const&)> handler) override;
	void async_hash2(storage_index_t storage, piece_index_t piece, int offset, disk_job_flags_t flags
		, std::function<void(piece_index_t, sha256_hash const&, storage_error const&)> handler) override;
	void async_move_storage(storage_index_t storage, std::string p, move_flags_t flags
		, std::function<void(status_t, std::string const&, storage_error const&)> handler) override;
	void async_release_files(storage_index_t storage
		, std::function<void()> handler = std::function<void()>()) override;
	void async_delete_files(storage_index_t storage, remove_flags_t options
		, std::function<void(storage_error const&)> handler) override;
	void async_check_files(storage_index_t storage
		, add_torrent_params const* resume_data
		, aux::vector<std::string, file_index_t> links
		, std::function<void(status_t, storage_error const&)> handler) override;
	void async_rename_file(storage_index_t storage, file_index_t index, std::string name
		, std::function<void(std::string const&, file_index_t, storage_error const&)> handler) override;
	void async_stop_torrent(storage_index_t storage
		, std::function<void()> handler) override;
	void async_set_file_priority(storage_index_t storage
		, aux::vector<download_priority_t, file_index_t> prio
		, std::function<void(storage_error const&
			, aux::vector<download_priority_t, file_index_t>)> handler) override;

	void async_clear_piece(storage_index_t storage, piece_index_t index
		, std::function<void(piece_index_t)> handler) override;

	// implements buffer_allocator_interface
	void free_disk_buffer(char* b) override
	{ m_buffer_pool.free_buffer(b); }

	void update_stats_counters(counters& c) const override;

	std::vector<open_file_state> get_status(storage_index_t) const override;

	// this submits all queued up jobs to the thread
	void submit_jobs() override;

	status_t do_partial_read(aux::disk_io_job* j);
	status_t do_read(aux::disk_io_job* j);
	status_t do_write(aux::disk_io_job* j);
	status_t do_hash(aux::disk_io_job* j);
	status_t do_hash2(aux::disk_io_job* j);

	status_t do_move_storage(aux::disk_io_job* j);
	status_t do_release_files(aux::disk_io_job* j);
	status_t do_delete_files(aux::disk_io_job* j);
	status_t do_check_fastresume(aux::disk_io_job* j);
	status_t do_rename_file(aux::disk_io_job* j);
	status_t do_stop_torrent(aux::disk_io_job* j);
	status_t do_file_priority(aux::disk_io_job* j);
	status_t do_clear_piece(aux::disk_io_job* j);

	void call_job_handlers();

private:

	struct job_queue : aux::pool_thread_interface
	{
		explicit job_queue(mmap_disk_io& owner) : m_owner(owner) {}

		void notify_all() override
		{
			m_job_cond.notify_all();
		}

		void thread_fun(aux::disk_io_thread_pool& pool, executor_work_guard<io_context::executor_type> work) override
		{
			ADD_OUTSTANDING_ASYNC(""mmap_disk_io::work"");
			m_owner.thread_fun(*this, pool);

			// w's dtor releases the io_context to allow the run() call to return
			// we do this once we stop posting new callbacks to it.
			// after the dtor has been called, the mmap_disk_io object may be destructed
			TORRENT_UNUSED(work);
			COMPLETE_ASYNC(""mmap_disk_io::work"");
		}

		mmap_disk_io& m_owner;

		// used to wake up the disk IO thread when there are new
		// jobs on the job queue (m_queued_jobs)
		std::condition_variable m_job_cond;

		// jobs queued for servicing
		jobqueue_t m_queued_jobs;
	};

	void thread_fun(job_queue& queue, aux::disk_io_thread_pool& pool);

	// returns true if the thread should exit
	static bool wait_for_job(job_queue& jobq, aux::disk_io_thread_pool& threads
		, std::unique_lock<std::mutex>& l);

	void add_completed_jobs(jobqueue_t& jobs);
	void add_completed_jobs_impl(jobqueue_t& jobs);

	void fail_jobs_impl(storage_error const& e, jobqueue_t& src, jobqueue_t& dst);

	void perform_job(aux::disk_io_job* j, jobqueue_t& completed_jobs);

	// this queues up another job to be submitted
	void add_job(aux::disk_io_job* j, bool user_add = true);
	void add_fence_job(aux::disk_io_job* j, bool user_add = true);

	void execute_job(aux::disk_io_job* j);
	void immediate_execute();
	void abort_jobs();
	void abort_hash_jobs(storage_index_t storage);

	// returns the maximum number of threads
	// the actual number of threads may be less
	int num_threads() const;
	job_queue& queue_for_job(aux::disk_io_job* j);
	aux::disk_io_thread_pool& pool_for_job(aux::disk_io_job* j);

	// set to true once we start shutting down
	std::atomic<bool> m_abort{false};

	// this is a counter of how many threads are currently running.
	// it's used to identify the last thread still running while
	// shutting down. This last thread is responsible for cleanup
	// must hold the job mutex to access
	int m_num_running_threads = 0;

	aux::disk_job_pool m_job_pool;

	// std::mutex to protect the m_generic_io_jobs and m_hash_io_jobs lists
	mutable std::mutex m_job_mutex;

	// most jobs are posted to m_generic_io_jobs
	// but hash jobs are posted to m_hash_io_jobs if m_hash_threads
	// has a non-zero maximum thread count
	job_queue m_generic_io_jobs;
	aux::disk_io_thread_pool m_generic_threads;
	job_queue m_hash_io_jobs;
	aux::disk_io_thread_pool m_hash_threads;

	// every write job is inserted into this map while it is in the job queue.
	// It is removed after the write completes. This will let subsequent reads
	// pull the buffers straight out of the queue instead of having to
	// synchronize with the writing thread(s)
	aux::store_buffer m_store_buffer;

	settings_interface const& m_settings;

	// we call close_oldest_file on the file_pool regularly. This is the next
	// time we should call it
	time_point m_next_close_oldest_file = min_time();

	// LRU cache of open files
	aux::file_view_pool m_file_pool;

	// disk cache
	aux::disk_buffer_pool m_buffer_pool;

	// total number of blocks in use by both the read
	// and the write cache. This is not supposed to
	// exceed m_cache_size

	counters& m_stats_counters;

	// this is the main thread io_context. Callbacks are
	// posted on this in order to have them execute in
	// the main thread.
	io_context& m_ios;

	// jobs that are completed are put on this queue
	// whenever the queue size grows from 0 to 1
	// a message is posted to the network thread, which
	// will then drain the queue and execute the jobs'
	// handler functions
	std::mutex m_completed_jobs_mutex;
	jobqueue_t m_completed_jobs;

	// storages that have had write activity recently and will get ticked
	// soon, for deferred actions (say, flushing partfile metadata)
	std::vector<std::pair<time_point, std::weak_ptr<mmap_storage>>> m_need_tick;
	std::mutex m_need_tick_mutex;

	// this is protected by the completed_jobs_mutex. It's true whenever
	// there's a call_job_handlers message in-flight to the network thread. We
	// only ever keep one such message in flight at a time, and coalesce
	// completion callbacks in m_completed jobs
	bool m_job_completions_in_flight = false;

	aux::vector<std::shared_ptr<mmap_storage>, storage_index_t> m_torrents;

	// indices into m_torrents to empty slots
	std::vector<storage_index_t> m_free_slots;

	std::atomic_flag m_jobs_aborted = ATOMIC_FLAG_INIT;

#if TORRENT_USE_ASSERTS
	int m_magic = 0x1337;
#endif
};

TORRENT_EXPORT std::unique_ptr<disk_interface> mmap_disk_io_constructor(
	io_context& ios, settings_interface const& sett, counters& cnt)
{
	return std::make_unique<mmap_disk_io>(ios, sett, cnt);
}

// ------- mmap_disk_io ------

	mmap_disk_io::mmap_disk_io(io_context& ios, settings_interface const& sett, counters& cnt)
		: m_generic_io_jobs(*this)
		, m_generic_threads(m_generic_io_jobs, ios)
		, m_hash_io_jobs(*this)
		, m_hash_threads(m_hash_io_jobs, ios)
		, m_settings(sett)
		, m_file_pool(sett.get_int(settings_pack::file_pool_size))
		, m_buffer_pool(ios)
		, m_stats_counters(cnt)
		, m_ios(ios)
	{
		settings_updated();
	}

	std::vector<open_file_state> mmap_disk_io::get_status(storage_index_t const st) const
	{
		return m_file_pool.get_status(st);
	}

	storage_holder mmap_disk_io::new_torrent(storage_params const& params
		, std::shared_ptr<void> const& owner)
	{
		TORRENT_ASSERT(params.files.is_valid());

		storage_index_t const idx = m_free_slots.empty()
			? m_torrents.end_index()
			: pop(m_free_slots);
		auto storage = std::make_shared<mmap_storage>(params, m_file_pool);
		storage->set_storage_index(idx);
		storage->set_owner(owner);
		if (idx == m_torrents.end_index())
		{
			// make sure there's always space in here to add another free slot.
			// stopping a torrent should never fail because it needs to allocate memory
			m_free_slots.reserve(m_torrents.size() + 1);
			m_torrents.emplace_back(std::move(storage));
		}
		else m_torrents[idx] = std::move(storage);
		return storage_holder(idx, *this);
	}

	void mmap_disk_io::remove_torrent(storage_index_t const idx)
	{
		m_torrents[idx].reset();
		m_free_slots.push_back(idx);
	}

#if TORRENT_USE_ASSERTS
	mmap_disk_io::~mmap_disk_io()
	{
		DLOG(""destructing mmap_disk_io\\n"");
		TORRENT_ASSERT(m_magic == 0x1337);
		m_magic = 0xdead;
		TORRENT_ASSERT(m_generic_io_jobs.m_queued_jobs.empty());
		TORRENT_ASSERT(m_hash_io_jobs.m_queued_jobs.empty());
	}
#endif

	void mmap_disk_io::abort(bool const wait)
	{
		DLOG(""mmap_disk_io::abort: (wait: %d)\\n"", int(wait));

		// first make sure queued jobs have been submitted
		// otherwise the queue may not get processed
		submit_jobs();

		// abuse the job mutex to make setting m_abort and checking the thread count atomic
		// see also the comment in thread_fun
		std::unique_lock<std::mutex> l(m_job_mutex);
		if (m_abort.exchange(true)) return;
		bool const no_threads = m_generic_threads.num_threads() == 0
			&& m_hash_threads.num_threads() == 0;
		// abort outstanding jobs belonging to this torrent

		DLOG(""aborting hash jobs\\n"");
		for (auto i = m_hash_io_jobs.m_queued_jobs.iterate(); i.get(); i.next())
			i.get()->flags |= aux::disk_io_job::aborted;
		l.unlock();

		// if there are no disk threads, we can't wait for the jobs here, because
		// we'd stall indefinitely
		if (no_threads)
		{
			abort_jobs();
		}

		DLOG(""aborting thread pools\\n"");
		// even if there are no threads it doesn't hurt to abort the pools
		// it prevents threads from being started after an abort which is a good
		// defensive programming measure
		m_generic_threads.abort(wait);
		m_hash_threads.abort(wait);
	}

	void mmap_disk_io::settings_updated()
	{
		TORRENT_ASSERT(m_magic == 0x1337);
		m_buffer_pool.set_settings(m_settings);
		m_file_pool.resize(m_settings.get_int(settings_pack::file_pool_size));

		int const num_threads = m_settings.get_int(settings_pack::aio_threads);
		int const num_hash_threads = m_settings.get_int(settings_pack::hashing_threads);
		DLOG(""set max threads(%d, %d)\\n"", num_threads, num_hash_threads);

		m_generic_threads.set_max_threads(num_threads);
		m_hash_threads.set_max_threads(num_hash_threads);
	}

	void mmap_disk_io::fail_jobs_impl(storage_error const& e, jobqueue_t& src, jobqueue_t& dst)
	{
		while (!src.empty())
		{
			aux::disk_io_job* j = src.pop_front();
			TORRENT_ASSERT((j->flags & aux::disk_io_job::in_progress) || !j->storage);

			if (j->action == aux::job_action_t::write)
			{
				m_store_buffer.erase({j->storage->storage_index(), j->piece, j->d.io.offset});
			}
			j->ret = status_t::fatal_disk_error;
			j->error = e;
			dst.push_back(j);
		}
	}

	namespace {

	typedef status_t (mmap_disk_io::*disk_io_fun_t)(aux::disk_io_job* j);

	// this is a jump-table for disk I/O jobs
	std::array<disk_io_fun_t, 13> const job_functions =
	{{
		&mmap_disk_io::do_read,
		&mmap_disk_io::do_write,
		&mmap_disk_io::do_hash,
		&mmap_disk_io::do_hash2,
		&mmap_disk_io::do_move_storage,
		&mmap_disk_io::do_release_files,
		&mmap_disk_io::do_delete_files,
		&mmap_disk_io::do_check_fastresume,
		&mmap_disk_io::do_rename_file,
		&mmap_disk_io::do_stop_torrent,
		&mmap_disk_io::do_file_priority,
		&mmap_disk_io::do_clear_piece,
		&mmap_disk_io::do_partial_read,
	}};

	} // anonymous namespace

	void mmap_disk_io::perform_job(aux::disk_io_job* j, jobqueue_t& completed_jobs)
	{
		TORRENT_ASSERT(j->next == nullptr);
		TORRENT_ASSERT((j->flags & aux::disk_io_job::in_progress) || !j->storage);

#if DEBUG_DISK_THREAD
		{
			std::unique_lock<std::mutex> l(m_job_mutex);

			DLOG(""perform_job job: %s ( %s%s) piece: %d offset: %d outstanding: %d\\n""
				, job_action_name[j->action]
				, (j->flags & disk_io_job::fence) ? ""fence "": """"
				, (j->flags & disk_io_job::force_copy) ? ""force_copy "": """"
				, static_cast<int>(j->piece), j->d.io.offset
				, j->storage ? j->storage->num_outstanding_jobs() : -1);
		}
#endif

		std::shared_ptr<mmap_storage> storage = j->storage;

		TORRENT_ASSERT(static_cast<int>(j->action) < int(job_functions.size()));

		m_stats_counters.inc_stats_counter(counters::num_running_disk_jobs, 1);

		// call disk function
		// TODO: in the future, propagate exceptions back to the handlers
		status_t ret = status_t::no_error;
		try
		{
			int const idx = static_cast<int>(j->action);
			ret = (this->*(job_functions[static_cast<std::size_t>(idx)]))(j);
		}
		catch (boost::system::system_error const& err)
		{
			ret = status_t::fatal_disk_error;
			j->error.ec = err.code();
			j->error.operation = operation_t::exception;
		}
		catch (std::bad_alloc const&)
		{
			ret = status_t::fatal_disk_error;
			j->error.ec = errors::no_memory;
			j->error.operation = operation_t::exception;
		}
		catch (std::exception const&)
		{
			ret = status_t::fatal_disk_error;
			j->error.ec = boost::asio::error::fault;
			j->error.operation = operation_t::exception;
		}

		// note that -2 errors are OK
		TORRENT_ASSERT(ret != status_t::fatal_disk_error
			|| (j->error.ec && j->error.operation != operation_t::unknown));

		m_stats_counters.inc_stats_counter(counters::num_running_disk_jobs, -1);

		j->ret = ret;

		completed_jobs.push_back(j);
	}

	status_t mmap_disk_io::do_partial_read(aux::disk_io_job* j)
	{
		auto& buffer = boost::get<disk_buffer_holder>(j->argument);
		TORRENT_ASSERT(buffer);

		time_point const start_time = clock_type::now();

		aux::open_mode_t const file_flags = file_flags_for_job(j);
		iovec_t b = {buffer.data() + j->d.io.buffer_offset, j->d.io.buffer_size};

		int const ret = j->storage->readv(m_settings, b
			, j->piece, j->d.io.offset, file_flags, j->error);

		TORRENT_ASSERT(ret >= 0 || j->error.ec);
		TORRENT_UNUSED(ret);

		if (!j->error.ec)
		{
			std::int64_t const read_time = total_microseconds(clock_type::now() - start_time);

			m_stats_counters.inc_stats_counter(counters::num_read_back);
			m_stats_counters.inc_stats_counter(counters::num_blocks_read);
			m_stats_counters.inc_stats_counter(counters::num_read_ops);
			m_stats_counters.inc_stats_counter(counters::disk_read_time, read_time);
			m_stats_counters.inc_stats_counter(counters::disk_job_time, read_time);
		}
		return status_t::no_error;
	}

	status_t mmap_disk_io::do_read(aux::disk_io_job* j)
	{
		j->argument = disk_buffer_holder(*this, m_buffer_pool.allocate_buffer(""send buffer""), default_block_size);
		auto& buffer = boost::get<disk_buffer_holder>(j->argument);
		if (!buffer)
		{
			j->error.ec = error::no_memory;
			j->error.operation = operation_t::alloc_cache_piece;
			return status_t::fatal_disk_error;
		}

		time_point const start_time = clock_type::now();

		aux::open_mode_t const file_flags = file_flags_for_job(j);
		iovec_t b = {buffer.data(), j->d.io.buffer_size};

		int const ret = j->storage->readv(m_settings, b
			, j->piece, j->d.io.offset, file_flags, j->error);

		TORRENT_ASSERT(ret >= 0 || j->error.ec);
		TORRENT_UNUSED(ret);

		if (!j->error.ec)
		{
			std::int64_t const read_time = total_microseconds(clock_type::now() - start_time);

			m_stats_counters.inc_stats_counter(counters::num_read_back);
			m_stats_counters.inc_stats_counter(counters::num_blocks_read);
			m_stats_counters.inc_stats_counter(counters::num_read_ops);
			m_stats_counters.inc_stats_counter(counters::disk_read_time, read_time);
			m_stats_counters.inc_stats_counter(counters::disk_job_time, read_time);
		}
		return status_t::no_error;
	}

	status_t mmap_disk_io::do_write(aux::disk_io_job* j)
	{
		time_point const start_time = clock_type::now();
		auto buffer = std::move(boost::get<disk_buffer_holder>(j->argument));

		iovec_t const b = { buffer.data(), j->d.io.buffer_size};
		aux::open_mode_t const file_flags = file_flags_for_job(j);

		m_stats_counters.inc_stats_counter(counters::num_writing_threads, 1);

		// the actual write operation
		int const ret = j->storage->writev(m_settings, b
			, j->piece, j->d.io.offset, file_flags, j->error);

		m_stats_counters.inc_stats_counter(counters::num_writing_threads, -1);

		if (!j->error.ec)
		{
			std::int64_t const write_time = total_microseconds(clock_type::now() - start_time);

			m_stats_counters.inc_stats_counter(counters::num_blocks_written);
			m_stats_counters.inc_stats_counter(counters::num_write_ops);
			m_stats_counters.inc_stats_counter(counters::disk_write_time, write_time);
			m_stats_counters.inc_stats_counter(counters::disk_job_time, write_time);
		}

		{
			std::lock_guard<std::mutex> l(m_need_tick_mutex);
			if (!j->storage->set_need_tick())
				m_need_tick.push_back({aux::time_now() + minutes(2), j->storage});
		}

		m_store_buffer.erase({j->storage->storage_index(), j->piece, j->d.io.offset});

		return ret != j->d.io.buffer_size
			? status_t::fatal_disk_error : status_t::no_error;
	}

	void mmap_disk_io::async_read(storage_index_t storage, peer_request const& r
		, std::function<void(disk_buffer_holder, storage_error const&)> handler
		, disk_job_flags_t const flags)
	{
		TORRENT_ASSERT(r.length <= default_block_size);
		TORRENT_ASSERT(r.length > 0);
		TORRENT_ASSERT(r.start >= 0);

		storage_error ec;
		if (r.length <= 0 || r.start < 0)
		{
			// this is an invalid read request.
			ec.ec = errors::invalid_request;
			ec.operation = operation_t::file_read;
			handler(disk_buffer_holder{}, ec);
			return;
		}

		// in case r.start is not aligned to a block, calculate that offset,
		// since that's how the store_buffer is indexed. block_offset is the
		// aligned offset to the first block this read touches. In the case the
		// request is aligned, it's the same as r.start
		int const block_offset = r.start - (r.start % default_block_size);
		// this is the offset into the block that we're reading from
		int const read_offset = r.start - block_offset;

		DLOG(""async_read piece: %d block: %d (read-offset: %d)\\n"", static_cast<int>(r.piece)
			, block_offset / default_block_size, read_offset);

		disk_buffer_holder buffer;

		if (read_offset + r.length > default_block_size)
		{
			// This is an unaligned request spanning two blocks. One of the two
			// blocks may be in the store buffer, or neither.
			// If neither is in the store buffer, we can just issue a normal
			// read job for the unaligned request.

			aux::torrent_location const loc1{storage, r.piece, block_offset};
			aux::torrent_location const loc2{storage, r.piece, block_offset + default_block_size};
			std::ptrdiff_t const len1 = default_block_size - read_offset;

			TORRENT_ASSERT(r.length > len1);

			int const ret = m_store_buffer.get2(loc1, loc2, [&](char const* buf1, char const* buf2)
			{
				buffer = disk_buffer_holder(*this, m_buffer_pool.allocate_buffer(""send buffer""), r.length);
				if (!buffer)
				{
					ec.ec = error::no_memory;
					ec.operation = operation_t::alloc_cache_piece;
					return 3;
				}

				if (buf1)
					std::memcpy(buffer.data(), buf1 + read_offset, std::size_t(len1));
				if (buf2)
					std::memcpy(buffer.data() + len1, buf2, std::size_t(r.length - len1));
				return (buf1 ? 2 : 0) | (buf2 ? 1 : 0);
			});

			if (ret == 3)
			{
				// both sides were found in the store buffer and the read request
				// was satisfied immediately
				handler(std::move(buffer), ec);
				return;
			}

			if (ret != 0)
			{
				TORRENT_ASSERT(ret == 1 || ret == 2);
				// only one side of the read request was found in the store
				// buffer, and we need to issue a partial read for the remaining
				// bytes
				aux::disk_io_job* j = m_job_pool.allocate_job(aux::job_action_t::partial_read);
				j->argument = std::move(buffer);
				j->storage = m_torrents[storage]->shared_from_this();
				j->piece = r.piece;
				j->d.io.offset = (ret == 1) ? r.start : block_offset + default_block_size;
				j->d.io.buffer_size = std::uint16_t((ret == 1) ? len1 : r.length - len1);
				j->d.io.buffer_offset = std::uint16_t((ret == 1) ? 0 : len1);
				j->flags = flags;
				j->callback = std::move(handler);

				if (j->storage->is_blocked(j))
				{
					// this means the job was queued up inside storage
					m_stats_counters.inc_stats_counter(counters::blocked_disk_jobs);
					DLOG(""blocked job: %s (torrent: %d total: %d)\\n""
						, job_name(j->action), j->storage ? j->storage->num_blocked() : 0
						, int(m_stats_counters[counters::blocked_disk_jobs]));
				}
				else
				{
					add_job(j);
				}
				return;
			}

			// if we couldn't find any block in the store buffer, just post it
			// as a normal read job
		}
		else
		{
			if (m_store_buffer.get({ storage, r.piece, block_offset }, [&](char const* buf)
			{
				buffer = disk_buffer_holder(*this, m_buffer_pool.allocate_buffer(""send buffer""), r.length);
				if (!buffer)
				{
					ec.ec = error::no_memory;
					ec.operation = operation_t::alloc_cache_piece;
					return;
				}

				std::memcpy(buffer.data(), buf + read_offset, std::size_t(r.length));
			}))
			{
				handler(std::move(buffer), ec);
				return;
			}
		}

		aux::disk_io_job* j = m_job_pool.allocate_job(aux::job_action_t::read);
		j->storage = m_torrents[storage]->shared_from_this();
		j->piece = r.piece;
		j->d.io.offset = r.start;
		j->d.io.buffer_size = std::uint16_t(r.length);
		j->flags = flags;
		j->callback = std::move(handler);

		if (j->storage->is_blocked(j))
		{
			// this means the job was queued up inside storage
			m_stats_counters.inc_stats_counter(counters::blocked_disk_jobs);
			DLOG(""blocked job: %s (torrent: %d total: %d)\\n""
				, job_name(j->action), j->storage ? j->storage->num_blocked() : 0
				, int(m_stats_counters[counters::blocked_disk_jobs]));
		}
		else
		{
			add_job(j);
		}
	}

	bool mmap_disk_io::async_write(storage_index_t const storage, peer_request const& r
		, char const* buf, std::shared_ptr<disk_observer> o
		, std::function<void(storage_error const&)> handler
		, disk_job_flags_t const flags)
	{
		bool exceeded = false;
		disk_buffer_holder buffer(*this, m_buffer_pool.allocate_buffer(
			exceeded, o, ""receive buffer""), default_block_size);
		if (!buffer) aux::throw_ex<std::bad_alloc>();
		std::memcpy(buffer.data(), buf, aux::numeric_cast<std::size_t>(r.length));

		TORRENT_ASSERT(r.start % default_block_size == 0);
		TORRENT_ASSERT(r.length <= default_block_size);

		aux::disk_io_job* j = m_job_pool.allocate_job(aux::job_action_t::write);
		j->storage = m_torrents[storage]->shared_from_this();
		j->piece = r.piece;
		j->d.io.offset = r.start;
		j->d.io.buffer_size = std::uint16_t(r.length);
		j->argument = std::move(buffer);
		j->callback = std::move(handler);
		j->flags = flags;

		m_store_buffer.insert({j->storage->storage_index(), j->piece, j->d.io.offset}
			, boost::get<disk_buffer_holder>(j->argument).data());

		if (j->storage->is_blocked(j))
		{
			// this means the job was queued up inside storage
			m_stats_counters.inc_stats_counter(counters::blocked_disk_jobs);
			DLOG(""blocked job: %s (torrent: %d total: %d)\\n""
				, job_name(j->action), j->storage ? j->storage->num_blocked() : 0
				, int(m_stats_counters[counters::blocked_disk_jobs]));
			return exceeded;
		}

		add_job(j);
		return exceeded;
	}

	void mmap_disk_io::async_hash(storage_index_t const storage
		, piece_index_t const piece, span<sha256_hash> const v2, disk_job_flags_t const flags
		, std::function<void(piece_index_t, sha1_hash const&, storage_error const&)> handler)
	{
		aux::disk_io_job* j = m_job_pool.allocate_job(aux::job_action_t::hash);
		j->storage = m_torrents[storage]->shared_from_this();
		j->piece = piece;
		j->d.h.block_hashes = v2;
		j->callback = std::move(handler);
		j->flags = flags;
		add_job(j);
	}

	void mmap_disk_io::async_hash2(storage_index_t const storage
		, piece_index_t const piece, int const offset, disk_job_flags_t const flags
		, std::function<void(piece_index_t, sha256_hash const&, storage_error const&)> handler)
	{
		aux::disk_io_job* j = m_job_pool.allocate_job(aux::job_action_t::hash2);
		j->storage = m_torrents[storage]->shared_from_this();
		j->piece = piece;
		j->d.io.offset = offset;
		j->callback = std::move(handler);
		j->flags = flags;
		add_job(j);
	}

	void mmap_disk_io::async_move_storage(storage_index_t const storage
		, std::string p, move_flags_t const flags
		, std::function<void(status_t, std::string const&, storage_error const&)> handler)
	{
		aux::disk_io_job* j = m_job_pool.allocate_job(aux::job_action_t::move_storage);
		j->storage = m_torrents[storage]->shared_from_this();
		j->argument = std::move(p);
		j->callback = std::move(handler);
		j->move_flags = flags;

		add_fence_job(j);
	}

	void mmap_disk_io::async_release_files(storage_index_t const storage
		, std::function<void()> handler)
	{
		aux::disk_io_job* j = m_job_pool.allocate_job(aux::job_action_t::release_files);
		j->storage = m_torrents[storage]->shared_from_this();
		j->callback = std::move(handler);

		add_fence_job(j);
	}

	void mmap_disk_io::abort_hash_jobs(storage_index_t const storage)
	{
		// abort outstanding hash jobs belonging to this torrent
		std::unique_lock<std::mutex> l(m_job_mutex);

		auto st = m_torrents[storage]->shared_from_this();
		// hash jobs
		for (auto i = m_hash_io_jobs.m_queued_jobs.iterate(); i.get(); i.next())
		{
			aux::disk_io_job* j = i.get();
			if (j->storage != st) continue;
			// only cancel volatile-read jobs. This means only full checking
			// jobs. These jobs are likely to have a pretty deep queue and
			// really gain from being cancelled. They can also be restarted
			// easily.
			if (!(j->flags & disk_interface::volatile_read)) continue;
			j->flags |= aux::disk_io_job::aborted;
		}
	}

	void mmap_disk_io::async_delete_files(storage_index_t const storage
		, remove_flags_t const options
		, std::function<void(storage_error const&)> handler)
	{
		abort_hash_jobs(storage);
		aux::disk_io_job* j = m_job_pool.allocate_job(aux::job_action_t::delete_files);
		j->storage = m_torrents[storage]->shared_from_this();
		j->callback = std::move(handler);
		j->argument = options;
		add_fence_job(j);
	}

	void mmap_disk_io::async_check_files(storage_index_t const storage
		, add_torrent_params const* resume_data
		, aux::vector<std::string, file_index_t> links
		, std::function<void(status_t, storage_error const&)> handler)
	{
		aux::disk_io_job* j = m_job_pool.allocate_job(aux::job_action_t::check_fastresume);
		j->storage = m_torrents[storage]->shared_from_this();
		j->argument = resume_data;
		j->callback = std::move(handler);

		aux::vector<std::string, file_index_t>* links_vector = nullptr;
		if (!links.empty()) links_vector = new aux::vector<std::string, file_index_t>(std::move(links));
		j->d.links = links_vector;

		add_fence_job(j);
	}

	void mmap_disk_io::async_rename_file(storage_index_t const storage
		, file_index_t const index, std::string name
		, std::function<void(std::string const&, file_index_t, storage_error const&)> handler)
	{
		aux::disk_io_job* j = m_job_pool.allocate_job(aux::job_action_t::rename_file);
		j->storage = m_torrents[storage]->shared_from_this();
		j->file_index = index;
		j->argument = std::move(name);
		j->callback = std::move(handler);
		add_fence_job(j);
	}

	void mmap_disk_io::async_stop_torrent(storage_index_t const storage
		, std::function<void()> handler)
	{
		auto st = m_torrents[storage]->shared_from_this();
		abort_hash_jobs(storage);

		aux::disk_io_job* j = m_job_pool.allocate_job(aux::job_action_t::stop_torrent);
		j->storage = st;
		j->callback = std::move(handler);
		add_fence_job(j);
	}

	void mmap_disk_io::async_set_file_priority(storage_index_t const storage
		, aux::vector<download_priority_t, file_index_t> prios
		, std::function<void(storage_error const&
			, aux::vector<download_priority_t, file_index_t>)> handler)
	{
		aux::disk_io_job* j = m_job_pool.allocate_job(aux::job_action_t::file_priority);
		j->storage = m_torrents[storage]->shared_from_this();
		j->argument = std::move(prios);
		j->callback = std::move(handler);

		add_fence_job(j);
	}

	void mmap_disk_io::async_clear_piece(storage_index_t const storage
		, piece_index_t const index, std::function<void(piece_index_t)> handler)
	{
		aux::disk_io_job* j = m_job_pool.allocate_job(aux::job_action_t::clear_piece);
		j->storage = m_torrents[storage]->shared_from_this();
		j->piece = index;
		j->callback = std::move(handler);

		// regular jobs are not guaranteed to be executed in-order
		// since clear piece must guarantee that all write jobs that
		// have been issued finish before the clear piece job completes

		// TODO: this is potentially very expensive. One way to solve
		// it would be to have a fence for just this one piece.
		// but it hardly seems worth the complexity and cost just for the edge
		// case of receiving a corrupt piece
		add_fence_job(j);
	}

	status_t mmap_disk_io::do_hash(aux::disk_io_job* j)
	{
		// we're not using a cache. This is the simple path
		// just read straight from the file
		TORRENT_ASSERT(m_magic == 0x1337);

		bool const v1 = bool(j->flags & disk_interface::v1_hash);
		bool const v2 = !j->d.h.block_hashes.empty();

		int const piece_size = v1 ? j->storage->files().piece_size(j->piece) : 0;
		int const piece_size2 = v2 ? j->storage->orig_files().piece_size2(j->piece) : 0;
		int const blocks_in_piece = v1 ? (piece_size + default_block_size - 1) / default_block_size : 0;
		int const blocks_in_piece2 = v2 ? j->storage->orig_files().blocks_in_piece2(j->piece) : 0;
		aux::open_mode_t const file_flags = file_flags_for_job(j);

		TORRENT_ASSERT(!v2 || int(j->d.h.block_hashes.size()) >= blocks_in_piece2);

		hasher h;
		int ret = 0;
		int offset = 0;
		int const blocks_to_read = std::max(blocks_in_piece, blocks_in_piece2);
		for (int i = 0; i < blocks_to_read; ++i)
		{
			bool const v2_block = i < blocks_in_piece2;

			DLOG(""do_hash: reading (piece: %d block: %d)\\n"", int(j->piece), i);

			time_point const start_time = clock_type::now();

			std::ptrdiff_t const len = v1 ? std::min(default_block_size, piece_size - offset) : 0;
			std::ptrdiff_t const len2 = v2_block ? std::min(default_block_size, piece_size2 - offset) : 0;

			hasher256 h2;

			if (!m_store_buffer.get({ j->storage->storage_index(), j->piece, offset }
				, [&](char const* buf)
				{
					if (v1)
					{
						h.update({ buf, len });
						ret = int(len);
					}
					if (v2_block)
					{
						h2.update({ buf, len2 });
						ret = int(len2);
					}
				}))
			{
				if (v1)
				{
					j->error.ec.clear();
					ret = j->storage->hashv(m_settings, h, len, j->piece, offset, file_flags, j->error);
					if (ret < 0) break;
				}
				if (v2_block)
				{
					j->error.ec.clear();
					ret = j->storage->hashv2(m_settings, h2, len2, j->piece, offset, file_flags, j->error);
					if (ret < 0) break;
				}
			}

			if (!j->error.ec)
			{
				std::int64_t const read_time = total_microseconds(clock_type::now() - start_time);

				m_stats_counters.inc_stats_counter(counters::num_blocks_read, blocks_to_read);
				m_stats_counters.inc_stats_counter(counters::num_read_ops);
				m_stats_counters.inc_stats_counter(counters::disk_hash_time, read_time);
				m_stats_counters.inc_stats_counter(counters::disk_job_time, read_time);
			}

			if (v2_block)
				j->d.h.block_hashes[i] = h2.final();

			if (ret <= 0) break;

			offset += default_block_size;
		}

		if (v1)
			j->d.h.piece_hash = h.final();
		return ret >= 0 ? status_t::no_error : status_t::fatal_disk_error;
	}

	status_t mmap_disk_io::do_hash2(aux::disk_io_job* j)
	{
		TORRENT_ASSERT(m_magic == 0x1337);

		int const piece_size = j->storage->files().piece_size2(j->piece);
		aux::open_mode_t const file_flags = file_flags_for_job(j);

		hasher256 h;
		int ret = 0;

		DLOG(""do_hash2: reading (piece: %d offset: %d)\\n"", int(j->piece), int(j->d.io.offset));

		time_point const start_time = clock_type::now();

		TORRENT_ASSERT(piece_size > j->d.io.offset);
		std::ptrdiff_t const len = std::min(default_block_size, piece_size - j->d.io.offset);

		if (!m_store_buffer.get({ j->storage->storage_index(), j->piece, j->d.io.offset }
			, [&](char const* buf)
		{
			h.update({ buf, len });
			ret = int(len);
		}))
		{
			ret = j->storage->hashv2(m_settings, h, len, j->piece, j->d.io.offset, file_flags, j->error);
			if (ret < 0) return status_t::fatal_disk_error;
		}

		if (!j->error.ec)
		{
			std::int64_t const read_time = total_microseconds(clock_type::now() - start_time);

			m_stats_counters.inc_stats_counter(counters::num_blocks_read);
			m_stats_counters.inc_stats_counter(counters::num_read_ops);
			m_stats_counters.inc_stats_counter(counters::disk_hash_time, read_time);
			m_stats_counters.inc_stats_counter(counters::disk_job_time, read_time);
		}

		j->d.piece_hash2 = h.final();
		return ret >= 0 ? status_t::no_error : status_t::fatal_disk_error;
	}

	status_t mmap_disk_io::do_move_storage(aux::disk_io_job* j)
	{
		// if this assert fails, something's wrong with the fence logic
		TORRENT_ASSERT(j->storage->num_outstanding_jobs() == 1);

		// if files have to be closed, that's the storage's responsibility
		status_t ret;
		std::string p;
		std::tie(ret, p) = j->storage->move_storage(boost::get<std::string>(j->argument)
			, j->move_flags, j->error);

		boost::get<std::string>(j->argument) = p;
		return ret;
	}

	status_t mmap_disk_io::do_release_files(aux::disk_io_job* j)
	{
		// if this assert fails, something's wrong with the fence logic
		TORRENT_ASSERT(j->storage->num_outstanding_jobs() == 1);
		j->storage->release_files(j->error);
		return j->error ? status_t::fatal_disk_error : status_t::no_error;
	}

	status_t mmap_disk_io::do_delete_files(aux::disk_io_job* j)
	{
		TORRENT_ASSERT(boost::get<remove_flags_t>(j->argument));

		// if this assert fails, something's wrong with the fence logic
		TORRENT_ASSERT(j->storage->num_outstanding_jobs() == 1);
		j->storage->delete_files(boost::get<remove_flags_t>(j->argument), j->error);
		return j->error ? status_t::fatal_disk_error : status_t::no_error;
	}

	status_t mmap_disk_io::do_check_fastresume(aux::disk_io_job* j)
	{
		// if this assert fails, something's wrong with the fence logic
		TORRENT_ASSERT(j->storage->num_outstanding_jobs() == 1);

		add_torrent_params const* rd = boost::get<add_torrent_params const*>(j->argument);
		add_torrent_params tmp;
		if (rd == nullptr) rd = &tmp;

		std::unique_ptr<aux::vector<std::string, file_index_t>> links(j->d.links);
		// check if the fastresume data is up to date
		// if it is, use it and return true. If it
		// isn't return false and the full check
		// will be run. If the links pointer is non-empty, it has the same number
		// of elements as there are files. Each element is either empty or contains
		// the absolute path to a file identical to the corresponding file in this
		// torrent. The storage must create hard links (or copy) those files. If
		// any file does not exist or is inaccessible, the disk job must fail.

		TORRENT_ASSERT(j->storage->files().piece_length() > 0);

		// always initialize the storage
		j->storage->initialize(m_settings, j->error);
		if (j->error) return status_t::fatal_disk_error;

		// we must call verify_resume() unconditionally of the setting below, in
		// order to set up the links (if present)
		bool const verify_success = j->storage->verify_resume_data(*rd
			, links ? *links : aux::vector<std::string, file_index_t>(), j->error);

		// j->error may have been set at this point, by verify_resume_data()
		// it's important to not have it cleared out subsequent calls, as long
		// as they succeed.

		if (m_settings.get_bool(settings_pack::no_recheck_incomplete_resume))
			return status_t::no_error;

		if (!aux::contains_resume_data(*rd))
		{
			// if we don't have any resume data, we still may need to trigger a
			// full re-check, if there are *any* files.
			storage_error ignore;
			return (j->storage->has_any_file(ignore))
				? status_t::need_full_check
				: status_t::no_error;
		}

		return verify_success
			? status_t::no_error
			: status_t::need_full_check;
	}

	status_t mmap_disk_io::do_rename_file(aux::disk_io_job* j)
	{
		// if this assert fails, something's wrong with the fence logic
		TORRENT_ASSERT(j->storage->num_outstanding_jobs() == 1);

		// if files need to be closed, that's the storage's responsibility
		j->storage->rename_file(j->file_index, boost::get<std::string>(j->argument)
			, j->error);
		return j->error ? status_t::fatal_disk_error : status_t::no_error;
	}

	status_t mmap_disk_io::do_stop_torrent(aux::disk_io_job* j)
	{
		// if this assert fails, something's wrong with the fence logic
		TORRENT_ASSERT(j->storage->num_outstanding_jobs() == 1);
		j->storage->release_files(j->error);
		return j->error ? status_t::fatal_disk_error : status_t::no_error;
	}

	void mmap_disk_io::update_stats_counters(counters& c) const
	{
		// These are atomic_counts, so it's safe to access them from
		// a different thread
		std::unique_lock<std::mutex> jl(m_job_mutex);

		c.set_value(counters::num_read_jobs, m_job_pool.read_jobs_in_use());
		c.set_value(counters::num_write_jobs, m_job_pool.write_jobs_in_use());
		c.set_value(counters::num_jobs, m_job_pool.jobs_in_use());
		c.set_value(counters::queued_disk_jobs, m_generic_io_jobs.m_queued_jobs.size()
			+ m_hash_io_jobs.m_queued_jobs.size());

		jl.unlock();

		// gauges
		c.set_value(counters::disk_blocks_in_use, m_buffer_pool.in_use());
	}

	status_t mmap_disk_io::do_file_priority(aux::disk_io_job* j)
	{
		j->storage->set_file_priority(m_settings
			, boost::get<aux::vector<download_priority_t, file_index_t>>(j->argument)
			, j->error);
		return status_t::no_error;
	}

	// this job won't return until all outstanding jobs on this
	// piece are completed or cancelled and the buffers for it
	// have been evicted
	status_t mmap_disk_io::do_clear_piece(aux::disk_io_job*)
	{
		// there's nothing to do here, by the time this is called the jobs for
		// this storage has been completed since this is a fence job
		return status_t::no_error;
	}

	void mmap_disk_io::add_fence_job(aux::disk_io_job* j, bool const user_add)
	{
		// if this happens, it means we started to shut down
		// the disk threads too early. We have to post all jobs
		// before the disk threads are shut down
		TORRENT_ASSERT(!m_abort);

		DLOG(""add_fence:job: %s (outstanding: %d)\\n""
			, job_name(j->action)
			, j->storage->num_outstanding_jobs());

		TORRENT_ASSERT(j->storage);
		m_stats_counters.inc_stats_counter(counters::num_fenced_read + static_cast<int>(j->action));

		int ret = j->storage->raise_fence(j, m_stats_counters);
		if (ret == aux::disk_job_fence::fence_post_fence)
		{
			std::unique_lock<std::mutex> l(m_job_mutex);
			TORRENT_ASSERT((j->flags & aux::disk_io_job::in_progress) || !j->storage);
			m_generic_io_jobs.m_queued_jobs.push_back(j);
			l.unlock();

			if (num_threads() == 0 && user_add)
				immediate_execute();

			return;
		}

		if (num_threads() == 0 && user_add)
			immediate_execute();
	}

	void mmap_disk_io::add_job(aux::disk_io_job* j, bool const user_add)
	{
		TORRENT_ASSERT(m_magic == 0x1337);

		TORRENT_ASSERT(!j->storage || j->storage->files().is_valid());
		TORRENT_ASSERT(j->next == nullptr);
		// if this happens, it means we started to shut down
		// the disk threads too early. We have to post all jobs
		// before the disk threads are shut down
		TORRENT_ASSERT(!m_abort);

		// this happens for read jobs that get hung on pieces in the
		// block cache, and then get issued
		if (j->flags & aux::disk_io_job::in_progress)
		{
			std::unique_lock<std::mutex> l(m_job_mutex);
			TORRENT_ASSERT((j->flags & aux::disk_io_job::in_progress) || !j->storage);
			m_generic_io_jobs.m_queued_jobs.push_back(j);

			// if we literally have 0 disk threads, we have to execute the jobs
			// immediately. If add job is called internally by the mmap_disk_io,
			// we need to defer executing it. We only want the top level to loop
			// over the job queue (as is done below)
			if (num_threads() == 0 && user_add)
			{
				l.unlock();
				immediate_execute();
			}
			return;
		}

		DLOG(""add_job: %s (outstanding: %d)\\n""
			, job_name(j->action)
			, j->storage ? j->storage->num_outstanding_jobs() : 0);

		// is the fence up for this storage?
		// jobs that are instantaneous are not affected by the fence, is_blocked()
		// will take ownership of the job and queue it up, in case the fence is up
		// if the fence flag is set, this job just raised the fence on the storage
		// and should be scheduled
		if (j->storage && j->storage->is_blocked(j))
		{
			m_stats_counters.inc_stats_counter(counters::blocked_disk_jobs);
			DLOG(""blocked job: %s (torrent: %d total: %d)\\n""
				, job_name(j->action), j->storage ? j->storage->num_blocked() : 0
				, int(m_stats_counters[counters::blocked_disk_jobs]));
			return;
		}

		std::unique_lock<std::mutex> l(m_job_mutex);

		TORRENT_ASSERT((j->flags & aux::disk_io_job::in_progress) || !j->storage);

		job_queue& q = queue_for_job(j);
		q.m_queued_jobs.push_back(j);
		// if we literally have 0 disk threads, we have to execute the jobs
		// immediately. If add job is called internally by the mmap_disk_io,
		// we need to defer executing it. We only want the top level to loop
		// over the job queue (as is done below)
		if (pool_for_job(j).max_threads() == 0 && user_add)
		{
			l.unlock();
			immediate_execute();
		}
	}

	void mmap_disk_io::immediate_execute()
	{
		while (!m_generic_io_jobs.m_queued_jobs.empty())
		{
			aux::disk_io_job* j = m_generic_io_jobs.m_queued_jobs.pop_front();
			execute_job(j);
		}
	}

	void mmap_disk_io::submit_jobs()
	{
		std::unique_lock<std::mutex> l(m_job_mutex);
		if (!m_generic_io_jobs.m_queued_jobs.empty())
		{
			m_generic_io_jobs.m_job_cond.notify_all();
			m_generic_threads.job_queued(m_generic_io_jobs.m_queued_jobs.size());
		}
		if (!m_hash_io_jobs.m_queued_jobs.empty())
		{
			m_hash_io_jobs.m_job_cond.notify_all();
			m_hash_threads.job_queued(m_hash_io_jobs.m_queued_jobs.size());
		}
	}

	void mmap_disk_io::execute_job(aux::disk_io_job* j)
	{
		jobqueue_t completed_jobs;
		if (j->flags & aux::disk_io_job::aborted)
		{
			j->ret = status_t::fatal_disk_error;
			j->error = storage_error(boost::asio::error::operation_aborted);
			completed_jobs.push_back(j);
			add_completed_jobs(completed_jobs);
			return;
		}

		perform_job(j, completed_jobs);
		if (!completed_jobs.empty())
			add_completed_jobs(completed_jobs);
	}

	bool mmap_disk_io::wait_for_job(job_queue& jobq, aux::disk_io_thread_pool& threads
		, std::unique_lock<std::mutex>& l)
	{
		TORRENT_ASSERT(l.owns_lock());

		// the thread should only go active if it is exiting or there is work to do
		// if the thread goes active on every wakeup it causes the minimum idle thread
		// count to be lower than it should be
		// for performance reasons we also want to avoid going idle and active again
		// if there is already work to do
		if (jobq.m_queued_jobs.empty())
		{
			threads.thread_idle();

			do
			{
				// if the number of wanted threads is decreased,
				// we may stop this thread
				// when we're terminating the last thread, make sure
				// we finish up all queued jobs first
				if (threads.should_exit()
					&& (jobq.m_queued_jobs.empty()
						|| threads.num_threads() > 1)
					// try_thread_exit must be the last condition
					&& threads.try_thread_exit(std::this_thread::get_id()))
				{
					// time to exit this thread.
					threads.thread_active();
					return true;
				}

				jobq.m_job_cond.wait(l);
			} while (jobq.m_queued_jobs.empty());

			threads.thread_active();
		}

		return false;
	}

	void mmap_disk_io::thread_fun(job_queue& queue, aux::disk_io_thread_pool& pool)
	{
		std::thread::id const thread_id = std::this_thread::get_id();

#ifdef _WIN32
		using SetThreadInformation_t = BOOL (WINAPI*)(HANDLE, THREAD_INFORMATION_CLASS, LPVOID, DWORD);
		auto SetThreadInformation =
			aux::get_library_procedure<aux::kernel32, SetThreadInformation_t>(""SetThreadInformation"");
		if (SetThreadInformation) {
			// MEMORY_PRIORITY_INFORMATION
			struct MPI {
				ULONG MemoryPriority;
			};
#ifndef MEMORY_PRIORITY_BELOW_NORMAL
			ULONG const MEMORY_PRIORITY_BELOW_NORMAL = 4;
#endif
			MPI info{MEMORY_PRIORITY_BELOW_NORMAL};
			SetThreadInformation(GetCurrentThread(), ThreadMemoryPriority
				, &info, sizeof(info));
		}
#endif

		DLOG(""started disk thread\\n"");

		std::unique_lock<std::mutex> l(m_job_mutex);

		++m_num_running_threads;
		m_stats_counters.inc_stats_counter(counters::num_running_threads, 1);

		for (;;)
		{
			aux::disk_io_job* j = nullptr;
			bool const should_exit = wait_for_job(queue, pool, l);
			if (should_exit) break;
			j = queue.m_queued_jobs.pop_front();
			l.unlock();

			TORRENT_ASSERT((j->flags & aux::disk_io_job::in_progress) || !j->storage);

			if (&pool == &m_generic_threads && thread_id == pool.first_thread_id())
			{
				time_point const now = aux::time_now();
				{
					std::unique_lock<std::mutex> l2(m_need_tick_mutex);
					while (!m_need_tick.empty() && m_need_tick.front().first < now)
					{
						std::shared_ptr<mmap_storage> st = m_need_tick.front().second.lock();
						m_need_tick.erase(m_need_tick.begin());
						if (st)
						{
							l2.unlock();
							st->tick();
							l2.lock();
						}
					}
				}

				if (now > m_next_close_oldest_file)
				{
					seconds const interval(m_settings.get_int(settings_pack::close_file_interval));
					if (interval <= seconds(0))
					{
						// check again in one minute, in case the setting changed
						m_next_close_oldest_file = now + minutes(1);
					}
					else
					{
						m_next_close_oldest_file = now + interval;
						m_file_pool.close_oldest();
					}
				}
			}

			execute_job(j);

			l.lock();
		}

		// do cleanup in the last running thread
		// if we're not aborting, that means we just configured the thread pool to
		// not have any threads (i.e. perform all disk operations in the network
		// thread). In this case, the cleanup will happen in abort().

		int const threads_left = --m_num_running_threads;
		if (threads_left > 0 || !m_abort)
		{
			DLOG(""exiting disk thread. num_threads: %d aborting: %d\\n""
				, threads_left, int(m_abort));
			TORRENT_ASSERT(m_magic == 0x1337);
			m_stats_counters.inc_stats_counter(counters::num_running_threads, -1);
			return;
		}

		// it is important to hold the job mutex while calling try_thread_exit()
		// and continue to hold it until checking m_abort above so that abort()
		// doesn't inadvertently trigger the code below when it thinks there are no
		// more disk I/O threads running
		l.unlock();

		DLOG(""last thread alive. (left: %d) cleaning up. (generic-jobs: %d hash-jobs: %d)\\n""
			, threads_left
			, m_generic_io_jobs.m_queued_jobs.size()
			, m_hash_io_jobs.m_queued_jobs.size());

		// at this point, there are no queued jobs left. However, main
		// thread is still running and may still have peer_connections
		// that haven't fully destructed yet, reclaiming their references
		// to read blocks in the disk cache. We need to wait until all
		// references are removed from other threads before we can go
		// ahead with the cleanup.
		// This is not supposed to happen because the disk thread is now scheduled
		// for shut down after all peers have shut down (see
		// session_impl::abort_stage2()).

		DLOG(""the last disk thread alive. cleaning up\\n"");

		abort_jobs();

		TORRENT_ASSERT(m_magic == 0x1337);
		m_stats_counters.inc_stats_counter(counters::num_running_threads, -1);
	}

	void mmap_disk_io::abort_jobs()
	{
		DLOG(""mmap_disk_io::abort_jobs\\n"");

		TORRENT_ASSERT(m_magic == 0x1337);
		if (m_jobs_aborted.test_and_set()) return;

		// close all files. This may take a long
		// time on certain OSes (i.e. Mac OS)
		// that's why it's important to do this in
		// the disk thread in parallel with stopping
		// trackers.
		m_file_pool.release();
		TORRENT_ASSERT(m_magic == 0x1337);
	}

	int mmap_disk_io::num_threads() const
	{
		return m_generic_threads.max_threads() + m_hash_threads.max_threads();
	}

	mmap_disk_io::job_queue& mmap_disk_io::queue_for_job(aux::disk_io_job* j)
	{
		if (m_hash_threads.max_threads() > 0 && j->action == aux::job_action_t::hash)
			return m_hash_io_jobs;
		else
			return m_generic_io_jobs;
	}

	aux::disk_io_thread_pool& mmap_disk_io::pool_for_job(aux::disk_io_job* j)
	{
		if (m_hash_threads.max_threads() > 0 && j->action == aux::job_action_t::hash)
			return m_hash_threads;
		else
			return m_generic_threads;
	}

	void mmap_disk_io::add_completed_jobs(jobqueue_t& jobs)
	{
		do
		{
			// when a job completes, it's possible for it to cause
			// a fence to be lowered, issuing the jobs queued up
			// behind the fence
			add_completed_jobs_impl(jobs);
			TORRENT_ASSERT(jobs.empty());
		} while (!jobs.empty());
	}

	void mmap_disk_io::add_completed_jobs_impl(jobqueue_t& jobs)
	{
		jobqueue_t new_jobs;
		int ret = 0;
		for (auto i = jobs.iterate(); i.get(); i.next())
		{
			aux::disk_io_job* j = i.get();
			TORRENT_ASSERT((j->flags & aux::disk_io_job::in_progress) || !j->storage);

			if (j->flags & aux::disk_io_job::fence)
			{
				m_stats_counters.inc_stats_counter(
					counters::num_fenced_read + static_cast<int>(j->action), -1);
			}

			TORRENT_ASSERT(j->storage);
			if (j->storage)
				ret += j->storage->job_complete(j, new_jobs);

			TORRENT_ASSERT(ret == new_jobs.size());
			TORRENT_ASSERT(!(j->flags & aux::disk_io_job::in_progress));
#if TORRENT_USE_ASSERTS
			TORRENT_ASSERT(j->job_posted == false);
			j->job_posted = true;
#endif
		}

		if (ret)
		{
			DLOG(""unblocked %d jobs (%d left)\\n"", ret
				, int(m_stats_counters[counters::blocked_disk_jobs]) - ret);
		}

		m_stats_counters.inc_stats_counter(counters::blocked_disk_jobs, -ret);
		TORRENT_ASSERT(int(m_stats_counters[counters::blocked_disk_jobs]) >= 0);

		if (m_abort.load())
		{
			jobqueue_t completed;

			while (!new_jobs.empty())
			{
				aux::disk_io_job* j = new_jobs.pop_front();
				TORRENT_ASSERT((j->flags & aux::disk_io_job::in_progress) || !j->storage);
				j->ret = status_t::fatal_disk_error;
				j->error = storage_error(boost::asio::error::operation_aborted);
				completed.push_back(j);
			}
			if (!completed.empty())
				add_completed_jobs(completed);
		}

		if (!new_jobs.empty())
		{
			{
				std::lock_guard<std::mutex> l(m_job_mutex);
				m_generic_io_jobs.m_queued_jobs.append(new_jobs);
			}

			{
				std::lock_guard<std::mutex> l(m_job_mutex);
				m_generic_io_jobs.m_job_cond.notify_all();
				m_generic_threads.job_queued(m_generic_io_jobs.m_queued_jobs.size());
			}
		}

		std::lock_guard<std::mutex> l(m_completed_jobs_mutex);
		m_completed_jobs.append(jobs);

		if (!m_job_completions_in_flight)
		{
			// we take this lock just to make the logging prettier (non-interleaved)
			DLOG(""posting job handlers (%d)\\n"", m_completed_jobs.size());

			post(m_ios, [this] { this->call_job_handlers(); });
			m_job_completions_in_flight = true;
		}
	}

	// This is run in the network thread
	void mmap_disk_io::call_job_handlers()
	{
		m_stats_counters.inc_stats_counter(counters::on_disk_counter);
		std::unique_lock<std::mutex> l(m_completed_jobs_mutex);

		DLOG(""call_job_handlers (%d)\\n"", m_completed_jobs.size());

		TORRENT_ASSERT(m_job_completions_in_flight);
		m_job_completions_in_flight = false;

		aux::disk_io_job* j = m_completed_jobs.get_all();
		l.unlock();

		aux::array<aux::disk_io_job*, 64> to_delete;
		int cnt = 0;

		while (j)
		{
			TORRENT_ASSERT(j->job_posted == true);
			TORRENT_ASSERT(j->callback_called == false);
//			DLOG(""   callback: %s\\n"", job_name(j->action));
			aux::disk_io_job* next = j->next;

#if TORRENT_USE_ASSERTS
			j->callback_called = true;
#endif
			j->call_callback();
			to_delete[cnt++] = j;
			j = next;
			if (cnt == int(to_delete.size()))
			{
				cnt = 0;
				m_job_pool.free_jobs(to_delete.data(), int(to_delete.size()));
			}
		}

		if (cnt > 0) m_job_pool.free_jobs(to_delete.data(), cnt);
	}
}

#endif // HAVE_MMAP || HAVE_MAP_VIEW_OF_FILE
",16342,True,3643.361267003765,median
"""! <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
CLASS zcl_datetime DEFINITION
  PUBLIC
  FINAL
  CREATE PROTECTED .

  PUBLIC SECTION.


    ""! <p class=""shorttext synchronized"" lang=""en"">Type of rounding</p>
    TYPES ty_rounding TYPE i .
    TYPES ty_diff TYPE decfloat16 .

    ""! <p class=""shorttext synchronized"" lang=""en"">Day of week</p>
    TYPES ty_day_of_week TYPE i .
    TYPES:

      ""! <p class=""shorttext synchronized"" lang=""en"">Structure with reference to CL_DATETIME</p>
      BEGIN OF ty_datetime_element,
        o_datetime TYPE REF TO zcl_datetime,
      END OF ty_datetime_element .
    TYPES:

      ""! <p class=""shorttext synchronized"" lang=""en"">ISO week</p>
      BEGIN OF ty_iso_week,
        week        TYPE i,
        year        TYPE i,
        day_of_week TYPE ty_day_of_week,
      END OF ty_iso_week .
    TYPES:

      ""! <p class=""shorttext synchronized"" lang=""en"">TT: List of datetime elements</p>
      ty_t_datetime_list TYPE STANDARD TABLE OF ty_datetime_element WITH EMPTY KEY .

    TYPES:
           ""! <p class=""shorttext synchronized"" lang=""en"">Fields Date &amp; Time</p>
           ty_datetime_field TYPE string.


    ""! <p class=""shorttext synchronized"" lang=""en"">Date</p>
    DATA m_date TYPE dats READ-ONLY .

    ""! <p class=""shorttext synchronized"" lang=""en"">Time</p>
    DATA m_time TYPE time READ-ONLY .

    CONSTANTS:

      ""! <p class=""shorttext synchronized"" lang=""en"">Fields date &amp; time</p>
      BEGIN OF c_fields,
        ""! Second
        second TYPE ty_datetime_field VALUE 'SECOND'  ##NO_TEXT,
        ""! Minute
        minute TYPE ty_datetime_field VALUE 'MINUTE'  ##NO_TEXT,
        ""! Hour
        hour   TYPE ty_datetime_field VALUE 'HOUR'    ##NO_TEXT,
        ""! Day
        day    TYPE ty_datetime_field VALUE 'DAY'     ##NO_TEXT,
        ""! Week
        week   TYPE ty_datetime_field VALUE 'WEEK'    ##NO_TEXT,
        ""! Month
        month  TYPE ty_datetime_field VALUE 'MONTH'   ##NO_TEXT,
        ""! Year
        year   TYPE ty_datetime_field VALUE 'YEAR'    ##NO_TEXT,
      END  OF c_fields .
    CONSTANTS:
      ""! <p class=""shorttext synchronized"" lang=""en"">Wellknown times</p>
      BEGIN OF c_times,
        ""! Begin of day.
        begin_of_day TYPE tims VALUE '000000' ##NO_TEXT,
        ""! Noon of day
        noon         TYPE tims VALUE '120000' ##NO_TEXT,
        ""! End of day
        end_of_day   TYPE tims VALUE '235959' ##NO_TEXT,
      END OF c_times .
    CONSTANTS:
      ""! <p class=""shorttext synchronized"" lang=""en"">Enum day of week</p>
      BEGIN OF c_day_of_week,
        ""! Monday
        monday    TYPE ty_day_of_week VALUE 1,
        ""! Tuesday
        tuesday   TYPE ty_day_of_week VALUE 2,
        ""! Wednesday
        wednesday TYPE ty_day_of_week VALUE 3,
        ""! Thursday
        thursday  TYPE ty_day_of_week VALUE 4,
        ""! Friday
        friday    TYPE ty_day_of_week VALUE 5,
        ""! Saturday
        saturday  TYPE ty_day_of_week VALUE 6,
        ""! Sunday
        sunday    TYPE ty_day_of_week VALUE 7,
      END OF c_day_of_week .
    CONSTANTS:
      ""! <p class=""shorttext synchronized"" lang=""en"">Enum months</p>
      BEGIN OF c_month,
        ""! January
        january   TYPE i VALUE 1,
        ""! February
        february  TYPE i VALUE 2,
        ""! March
        march     TYPE i VALUE 3,
        ""! April
        april     TYPE i VALUE 4,
        ""! May
        may       TYPE i VALUE 5,
        ""! June
        june      TYPE i VALUE 6,
        ""! July
        july      TYPE i VALUE 7,
        ""! August
        august    TYPE i VALUE 8,
        ""! September
        september TYPE i VALUE 9,
        ""! October
        october   TYPE i VALUE 10,
        ""! November
        november  TYPE i VALUE 11,
        ""! December
        december  TYPE i VALUE 12,
      END OF c_month .
    ""! <p class=""shorttext synchronized"" lang=""en"">UTC timezone</p>
    CONSTANTS c_utc TYPE tznzone VALUE 'UTC' ##NO_TEXT.
    CONSTANTS:

      ""! <p class=""shorttext synchronized"" lang=""en"">Constants for days / years</p>
      BEGIN OF c_day_of_year,
        ""! First day of year. Always 1st of January
        first(4)                   TYPE c VALUE '0101',
        ""! Last day of year. Always 31st of December
        last(4)                    TYPE c VALUE '1231',
        ""! Number of days in a leap year
        max_days_in_leap_year      TYPE i VALUE 366,
        ""! Number of days in a none leap year
        max_days_in_none_leap_year TYPE i VALUE 365,
      END OF c_day_of_year .
    CONSTANTS:
      ""! <p class=""shorttext synchronized"" lang=""en"">Mode rounding</p>
      BEGIN OF c_rouding,
        ""!  Round away from zero if value is exactly half
        round_half_up   TYPE ty_rounding VALUE cl_abap_math=>round_half_up,
        ""! Round to zero if value is exactly half
        round_half_down TYPE ty_rounding VALUE cl_abap_math=>round_half_down,
        ""! Round so last digit is an even no. if value is exactly half
        round_half_even TYPE ty_rounding VALUE cl_abap_math=>round_half_even,
        ""!  Round away from zero
        round_up        TYPE ty_rounding VALUE cl_abap_math=>round_up,
        ""! Round to Zero
        round_down      TYPE ty_rounding VALUE cl_abap_math=>round_down,
        ""! Round to Positive Infinity
        round_ceiling   TYPE ty_rounding VALUE cl_abap_math=>round_ceiling,
        ""! Round to Negative Infinity
        round_floor     TYPE ty_rounding VALUE cl_abap_math=>round_floor,
        ""! Do not perform any rounding
        round_nothing   TYPE ty_rounding VALUE -1,
      END OF c_rouding .
    CONSTANTS:

      ""! <p class=""shorttext synchronized"" lang=""en"">General constants for date calculations</p>
      BEGIN OF c_time_constants,
        ""! Seconds per day (24 hours)
        num_seconds_per_day         TYPE i          VALUE 86400,
        ""! Minutes per day (24 hours)
        num_seconds_per_minute      TYPE i          VALUE 60,
        ""! Seconds per hour
        num_seconds_per_hour        TYPE i          VALUE 3600,
        ""! Seconds per week
        num_seconds_per_week        TYPE i          VALUE 604800,
        ""! Approximate / average seconds per month
        num_seconds_aprox_per_month TYPE decfloat16 VALUE '2628003.6',
        ""! Approximate / average seconds per year
        num_seconds_per_year        TYPE i          VALUE 22075200,
        ""! Minutes per Hour
        num_minutes_per_hour        TYPE i          VALUE 60,
        ""! Minutes per Day (24 hours)
        num_houres_per_day          TYPE i          VALUE 24,
        ""! Number of days in a leap year
        num_days_per_leap_year      TYPE i          VALUE 366,
        ""! Number of day in a none leap year
        num_days_per_none_leap_year TYPE i          VALUE 365,
      END OF c_time_constants .

    ""! <p class=""shorttext synchronized"" lang=""en"">Create a list of DateTime objects with an intervall</p>
    ""!
    ""! @parameter io_start           | <p class=""shorttext synchronized"" lang=""en"">Starting at DateTime</p>
    ""! @parameter iv_increment_field | <p class=""shorttext synchronized"" lang=""en"">Which field should be incremented?</p>
    ""! @parameter iv_increment_value | <p class=""shorttext synchronized"" lang=""en"">Value to increment</p>
    ""! @parameter iv_num_of_elements | <p class=""shorttext synchronized"" lang=""en"">Number of passes</p>
    ""! @parameter rt_datetime_list   | <p class=""shorttext synchronized"" lang=""en"">List of DateTime objects</p>
    CLASS-METHODS create_list
      IMPORTING
        !io_start               TYPE REF TO zcl_datetime
        !iv_increment_field     TYPE ty_datetime_field
        !iv_increment_value     TYPE i
        !iv_num_of_elements     TYPE i
      RETURNING
        VALUE(rt_datetime_list) TYPE ty_t_datetime_list .

    ""! <p class=""shorttext synchronized"" lang=""en"">Creating an instance based on date &amp; time</p>
    ""!
    ""! @parameter iv_date                    | <p class=""shorttext synchronized"" lang=""en"">Date</p>
    ""! @parameter iv_time                    | <p class=""shorttext synchronized"" lang=""en"">Time</p>
    ""! @raising   cx_parameter_invalid_range | <p class=""shorttext synchronized"" lang=""en"">Invalid parameters</p>
    CLASS-METHODS from_date
      IMPORTING
        !iv_date           TYPE dats
        !iv_time           TYPE tims DEFAULT c_times-begin_of_day
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime
      RAISING
        cx_parameter_invalid_range .

    ""! <p class=""shorttext synchronized"" lang=""en"">Creating an instance based on ISO 8601 timestamp</p>
    ""!
    ""! @parameter iv_iso8601  | <p class=""shorttext synchronized"" lang=""en"">ISO timestamp like 2021-01-01T01:01:01+01:00</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime</p>
    CLASS-METHODS from_iso_timestamp
      IMPORTING
        !iv_iso8601        TYPE string
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Creating an instance based on a timestamp</p>
    ""!
    ""! @parameter iv_ts       | <p class=""shorttext synchronized"" lang=""en"">Timestamp</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    CLASS-METHODS from_long_timestamp
      IMPORTING
        !iv_ts             TYPE timestampl
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Creating an instance based current date &amp; time</p>
    ""!
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    CLASS-METHODS from_now
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Creating an instance based on a timestamp</p>
    ""!
    ""! @parameter iv_ts         | <p class=""shorttext synchronized"" lang=""en"">Timestamp</p>
    ""! @parameter pr_o_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    CLASS-METHODS from_timestamp
      IMPORTING
        !iv_ts               TYPE timestamp
      RETURNING
        VALUE(pr_o_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Creating an instance with current date &amp; time 00:00:00</p>
    ""!
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    CLASS-METHODS from_today
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns max of 2 DateTime objects</p>
    ""!
    ""! @parameter iv_ignore_time | <p class=""shorttext synchronized"" lang=""en"">Ignore time?</p>
    CLASS-METHODS max
      IMPORTING
        !io_datetime_01 TYPE REF TO zcl_datetime
        !io_datetime_02 TYPE REF TO zcl_datetime
        !iv_ignore_time TYPE abap_bool DEFAULT abap_true
      RETURNING
        VALUE(ro_max)   TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns min of 2 DateTime objects</p>
    ""!
    ""! @parameter iv_ignore_time | <p class=""shorttext synchronized"" lang=""en"">Ignore time?</p>
    CLASS-METHODS min
      IMPORTING
        !io_datetime_01 TYPE REF TO zcl_datetime
        !io_datetime_02 TYPE REF TO zcl_datetime
        !iv_ignore_time TYPE abap_bool DEFAULT abap_true
      RETURNING
        VALUE(ro_min)   TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Determines of 2 DateTimes the min &amp; max value</p>
    ""!
    ""! @parameter iv_ignore_time  | <p class=""shorttext synchronized"" lang=""en"">Ignore time?</p>
    ""! @parameter eo_min_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    ""! @parameter eo_max_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    CLASS-METHODS min_max
      IMPORTING
        !io_datetime_01  TYPE REF TO zcl_datetime
        !io_datetime_02  TYPE REF TO zcl_datetime
        !iv_ignore_time  TYPE abap_bool DEFAULT abap_true
      EXPORTING
        !eo_min_datetime TYPE REF TO zcl_datetime
        !eo_max_datetime TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Changes a field of date (e.g Hour, Day...)</p>
    ""!
    ""! @parameter iv_field    | <p class=""shorttext synchronized"" lang=""en"">Fields of DateTime (hour, minute, month...)</p>
    ""! @parameter iv_value    | <p class=""shorttext synchronized"" lang=""en"">Value (negative values = sub)</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">Instance of DateTime object for method chaining</p>
    METHODS add
      IMPORTING
        !iv_field          TYPE ty_datetime_field
        !iv_value          TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .


    ""! <p class=""shorttext synchronized"" lang=""en"">Add days</p>
    ""!
    ""! @parameter iv_value    | <p class=""shorttext synchronized"" lang=""en"">Number of days</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS add_days
      IMPORTING
        !iv_value          TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .


    ""! <p class=""shorttext synchronized"" lang=""en"">Add hours</p>
    ""!
    ""! @parameter iv_value    | <p class=""shorttext synchronized"" lang=""en"">Number of hours</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS add_hours
      IMPORTING
        !iv_value          TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Add minutes</p>
    ""!
    ""! @parameter iv_value    | <p class=""shorttext synchronized"" lang=""en"">Number of Minutes</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS add_minutes
      IMPORTING
        !iv_value          TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Add month</p>
    METHODS add_months
      IMPORTING
        !iv_value          TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Add seconds</p>
    ""!
    ""! @parameter iv_value    | <p class=""shorttext synchronized"" lang=""en"">Number of seconds</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS add_seconds
      IMPORTING
        !iv_value          TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Add weeks</p>
    ""!
    ""! @parameter iv_value    | <p class=""shorttext synchronized"" lang=""en"">Number of weeks</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS add_weeks
      IMPORTING
        !iv_value          TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Add years</p>
    ""!
    ""! @parameter iv_value    | <p class=""shorttext synchronized"" lang=""en"">Number of years</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS add_years
      IMPORTING
        !iv_value          TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns the date of current DateTime</p>
    ""!
    ""! @parameter rv_date | <p class=""shorttext synchronized"" lang=""en"">Date of current DateTime object</p>
    METHODS as_date
      RETURNING
        VALUE(rv_date) TYPE dats .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns a ISO 8601 timestamp of current DateTime</p>
    ""!
    ""! @parameter rv_iso_timestamp | <p class=""shorttext synchronized"" lang=""en"">ISO 8601 timestamp</p>
    METHODS as_iso_timestamp
      RETURNING
        VALUE(rv_iso_timestamp) TYPE string .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns a timestamp of current DateTime</p>
    ""!
    ""! @parameter rv_timestamp | <p class=""shorttext synchronized"" lang=""en"">Date &amp; Time as timestamp</p>
    METHODS as_long_timestamp
      RETURNING
        VALUE(rv_timestamp) TYPE timestampl .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns a timestamp of current DateTime</p>
    ""!
    ""! @parameter rv_timestamp | <p class=""shorttext synchronized"" lang=""en"">Date &amp; Time as timestamp</p>
    METHODS as_timestamp
      RETURNING
        VALUE(rv_timestamp) TYPE timestamp .

    ""! <p class=""shorttext synchronized"" lang=""en"">Set DateTime to begin of day</p>
    ""!
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS begin_of_day
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Set DateTime to begin of month</p>
    ""!
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS begin_of_month
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Set DateTime to begin of quarter</p>
    ""!
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS begin_of_quarter
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Set DateTime to begin of week</p>
    ""!
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS begin_of_week
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Set DateTime to begin of year</p>
    ""!
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS begin_of_year
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Clones DateTime object to a new instance</p>
    ""!
    ""! @parameter ro_clone | <p class=""shorttext synchronized"" lang=""en"">Clone of current instance</p>
    METHODS clone
      RETURNING
        VALUE(ro_clone) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Set day to a day of week</p>
    ""!
    ""! @parameter pi_day_of_week | <p class=""shorttext synchronized"" lang=""en"">Day of week</p>
    ""! @parameter pr_o_datetime  | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS day_of_week
      IMPORTING
        !pi_day_of_week      TYPE ty_day_of_week
      RETURNING
        VALUE(pr_o_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Difference between to DateTime objects</p>
    ""!
    ""! @parameter io_datetime       | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    ""! @parameter iv_field          | <p class=""shorttext synchronized"" lang=""en"">Fields date &amp; time</p>
    ""! @parameter iv_round_mode     | <p class=""shorttext synchronized"" lang=""en"">Mode of rounding</p>
    ""! @parameter iv_round_decimals | <p class=""shorttext synchronized"" lang=""en"">Number of decimals for rounding</p>
    ""! @parameter rv_diff           | <p class=""shorttext synchronized"" lang=""en"">Difference</p>
    METHODS diff
      IMPORTING
        !io_datetime       TYPE REF TO zcl_datetime
        !iv_field          TYPE ty_datetime_field
        !iv_round_mode     TYPE ty_rounding DEFAULT zcl_datetime=>c_rouding-round_nothing
        !iv_round_decimals TYPE i DEFAULT 0
      RETURNING
        VALUE(rv_diff)     TYPE ty_diff .

    ""! <p class=""shorttext synchronized"" lang=""en"">Set DateTime to end of day</p>
    ""!
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS end_of_day
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Set DateTime to end of month</p>
    ""!
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS end_of_month
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Set DateTime to begin of quarter</p>
    ""!
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS end_of_quarter
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Set DateTime to begin of week</p>
    ""!
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS end_of_week
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Set DateTime to end of year</p>
    ""!
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS end_of_year
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Set DateTime to monday of 1st calendar week in year</p>
    ""!
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS first_calendar_week
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns the century of DateTime</p>
    ""!
    ""! @parameter rv_century | <p class=""shorttext synchronized"" lang=""en"">The century</p>
    METHODS get_century
      RETURNING
        VALUE(rv_century) TYPE i .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns the name of day of week</p>
    ""!
    ""! @parameter rv_dayname | <p class=""shorttext synchronized"" lang=""en"">Name of day of week</p>
    METHODS get_dayname
      RETURNING
        VALUE(rv_dayname) TYPE string .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns the day of month (1..31)</p>
    ""!
    ""! @parameter rv_day_of_month | <p class=""shorttext synchronized"" lang=""en"">Day in month (1..31)</p>
    METHODS get_day_of_month
      RETURNING
        VALUE(rv_day_of_month) TYPE i .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns day of week (1..7)</p>
    ""!
    ""! @parameter rv_day_of_week | <p class=""shorttext synchronized"" lang=""en"">Day of week (1..7)</p>
    METHODS get_day_of_week
      RETURNING
        VALUE(rv_day_of_week) TYPE ty_day_of_week .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns the day of year (1..365)</p>
    ""!
    ""! @parameter rv_day_of_year | <p class=""shorttext synchronized"" lang=""en"">Day of year (1..365)</p>
    METHODS get_day_of_year
      RETURNING
        VALUE(rv_day_of_year) TYPE i .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns day of week of 1st of january</p>
    ""!
    ""! @parameter iv_year_offset | <p class=""shorttext synchronized"" lang=""en"">Offset Bezugsjahr (+1 next year, -1 previous year)</p>
    ""! @parameter rv_doom_day    | <p class=""shorttext synchronized"" lang=""en"">Day of week of 1st of januaray</p>
    METHODS get_doom_day
      IMPORTING
        !iv_year_offset    TYPE i DEFAULT 0
      RETURNING
        VALUE(rv_doom_day) TYPE ty_day_of_week .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns the gregorian day (days since 1.1.0001)</p>
    ""!
    ""! @parameter rv_gregorian_day | <p class=""shorttext synchronized"" lang=""en"">Gregorian day</p>
    METHODS get_gregorian_day
      RETURNING
        VALUE(rv_gregorian_day) TYPE i .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns the ISO Week</p>
    ""!
    ""! @parameter rs_iso_week | <p class=""shorttext synchronized"" lang=""en"">calendar week</p>
    METHODS get_iso_week
      RETURNING
        VALUE(rs_iso_week) TYPE ty_iso_week .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns month of DateTime</p>
    METHODS get_month
      RETURNING
        VALUE(rv_month) TYPE i .

    ""! <p class=""shorttext synchronized"" lang=""en"">Retunrs number of days in month of current DateTime object</p>
    ""!
    ""! @parameter rv_number_of_days_of_month | <p class=""shorttext synchronized"" lang=""en"">Number of days in month</p>
    METHODS get_number_of_days_of_month
      RETURNING
        VALUE(rv_number_of_days_of_month) TYPE i .

    ""! <p class=""shorttext synchronized"" lang=""en"">Retunrs number of days in year of current DateTime object</p>
    ""!
    ""! @parameter rv_number_of_days_of_year | <p class=""shorttext synchronized"" lang=""en"">Number of days in year</p>
    METHODS get_number_of_days_of_year
      RETURNING
        VALUE(rv_number_of_days_of_year) TYPE i .

    ""! <p class=""shorttext synchronized"" lang=""en"">Retunrs the quarter of current DateTime object (1..4)</p>
    ""!
    ""! @parameter rv_quarter | <p class=""shorttext synchronized"" lang=""en"">The quarter</p>
    METHODS get_quarter
      RETURNING
        VALUE(rv_quarter) TYPE i .


    ""! <p class=""shorttext synchronized"" lang=""en"">Returns last day of year</p>
    ""!
    ""! @parameter rv_last_day_of_month | <p class=""shorttext synchronized"" lang=""en"">Last day of months</p>
    METHODS get_ultimo
      RETURNING
        VALUE(rv_last_day_of_month) TYPE dats .

    ""! <p class=""shorttext synchronized"" lang=""en"">Returns the year of current DateTime object</p>
    ""!
    ""! @parameter rv_year | <p class=""shorttext synchronized"" lang=""en"">The year of date</p>
    METHODS get_year
      RETURNING
        VALUE(rv_year) TYPE i .

    ""! <p class=""shorttext synchronized"" lang=""en"">Is the other DateTime after this DateTime?</p>
    ""!
    ""! @parameter io_datetime    | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    ""! @parameter iv_ignore_time | <p class=""shorttext synchronized"" lang=""en"">Ignore time?</p>
    METHODS is_after
      IMPORTING
        !io_datetime       TYPE REF TO zcl_datetime
        !iv_ignore_time    TYPE abap_bool DEFAULT abap_true
      RETURNING
        VALUE(pr_is_after) TYPE abap_bool .

    ""! <p class=""shorttext synchronized"" lang=""en"">Is the other DateTime equal to this DateTime?</p>
    ""!
    ""! @parameter io_datetime    | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    ""! @parameter iv_ignore_time | <p class=""shorttext synchronized"" lang=""en"">Ignore time?</p>
    METHODS is_after_or_equal
      IMPORTING
        !io_datetime                TYPE REF TO zcl_datetime
        !iv_ignore_time             TYPE abap_bool DEFAULT abap_true
      RETURNING
        VALUE(pr_is_after_or_equal) TYPE abap_bool .

    ""! <p class=""shorttext synchronized"" lang=""en"">Is the other DateTime before this DateTime?</p>
    ""!
    ""! @parameter io_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS is_before
      IMPORTING
        !io_datetime        TYPE REF TO zcl_datetime
        !iv_ignore_time     TYPE abap_bool DEFAULT abap_true
      RETURNING
        VALUE(rv_is_before) TYPE abap_bool .

    ""! <p class=""shorttext synchronized"" lang=""en"">Is the other DateTime before or equal to this DateTime?</p>
    ""!
    ""! @parameter io_datetime    | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    ""! @parameter iv_ignore_time | <p class=""shorttext synchronized"" lang=""en"">Ignore time?</p>
    METHODS is_before_or_equal
      IMPORTING
        !io_datetime                 TYPE REF TO zcl_datetime
        !iv_ignore_time              TYPE abap_bool DEFAULT abap_true
      RETURNING
        VALUE(rv_is_before_or_equal) TYPE abap_bool .

    ""! <p class=""shorttext synchronized"" lang=""en"">Is the other DateTime equal this DateTime?</p>
    ""!
    ""! @parameter io_datetime    | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    ""! @parameter iv_ignore_time | <p class=""shorttext synchronized"" lang=""en"">Ignore time?</p>
    METHODS is_equal
      IMPORTING
        !io_datetime        TYPE REF TO zcl_datetime
        !iv_ignore_time     TYPE abap_bool DEFAULT abap_true
      RETURNING
        VALUE(rv_is_before) TYPE abap_bool .

    ""! <p class=""shorttext synchronized"" lang=""en"">Is the day of DateTime th last in month?</p>
    ""!
    ""! @parameter rv_is_last_day_of_month | <p class=""shorttext synchronized"" lang=""en"">Last day of Month?</p>
    METHODS is_last_day_of_month
      RETURNING
        VALUE(rv_is_last_day_of_month) TYPE abap_bool .

    ""! <p class=""shorttext synchronized"" lang=""en"">Is the year a leap year?</p>
    ""!
    ""! @parameter rv_is_leap | <p class=""shorttext synchronized"" lang=""en"">Leap year?</p>
    METHODS is_leap_year
      RETURNING
        VALUE(rv_is_leap) TYPE abap_bool .

    ""! <p class=""shorttext synchronized"" lang=""en"">Set a Field (day, hour, seconds...)</p>
    ""!
    ""! @parameter iv_field    | <p class=""shorttext synchronized"" lang=""en"">Fields Date &amp; Time</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS set
      IMPORTING
        !iv_field          TYPE ty_datetime_field
        !iv_value          TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Change a Field (day, hour, seconds...)</p>
    ""!
    ""! @parameter iv_field    | <p class=""shorttext synchronized"" lang=""en"">Fields of DateTime (day, hour, second)</p>
    ""! @parameter iv_value    | <p class=""shorttext synchronized"" lang=""en"">Value (negatives values = add)</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">Instance of current DateTime for method chaining</p>
    METHODS subtract
      IMPORTING
        !iv_field            TYPE ty_datetime_field
        VALUE(iv_value)      TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Sub days</p>
    ""!
    ""! @parameter iv_value    | <p class=""shorttext synchronized"" lang=""en"">Number of days</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS sub_days
      IMPORTING
        !iv_value            TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Sub hours</p>
    ""!
    ""! @parameter iv_value    | <p class=""shorttext synchronized"" lang=""en"">Number of hours</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS sub_hours
      IMPORTING
        !iv_value            TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Sub Minutes</p>
    ""!
    ""! @parameter iv_value    | <p class=""shorttext synchronized"" lang=""en"">Number of minutes</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS sub_minutes
      IMPORTING
        !iv_value            TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Sub months</p>
    ""!
    ""! @parameter iv_value    | <p class=""shorttext synchronized"" lang=""en"">Number of weeks</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS sub_months
      IMPORTING
        !iv_value            TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Sub seconds</p>
    ""!
    ""! @parameter iv_value    | <p class=""shorttext synchronized"" lang=""en"">Number of seconds</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS sub_seconds
      IMPORTING
        !iv_value            TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Sub weeks</p>
    ""!
    ""! @parameter iv_value    | <p class=""shorttext synchronized"" lang=""en"">Number of weeks</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS sub_weeks
      IMPORTING
        !iv_value            TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .

    ""! <p class=""shorttext synchronized"" lang=""en"">Sub years</p>
    ""!
    ""! @parameter iv_value    | <p class=""shorttext synchronized"" lang=""en"">Number of years</p>
    ""! @parameter ro_datetime | <p class=""shorttext synchronized"" lang=""en"">DateTime object</p>
    METHODS sub_years
      IMPORTING
        !iv_value            TYPE i
      RETURNING
        VALUE(ro_datetime) TYPE REF TO zcl_datetime .
  PROTECTED SECTION.
  PRIVATE SECTION.

    TYPES:
      ty_ts_string(14) TYPE c .
ENDCLASS.



CLASS zcl_datetime IMPLEMENTATION.


  METHOD add.

    DATA: unit TYPE t006-msehi.

    CASE iv_field.
      WHEN c_fields-second.
        unit = 'S'.
      WHEN c_fields-minute.
        unit = 'MIN'.
      WHEN c_fields-hour.
        unit = 'STD'.
      WHEN c_fields-day.
        unit = 'TAG'.
      WHEN c_fields-week.
        unit = 'WCH'.
      WHEN c_fields-month.
        unit = 'MON'.
      WHEN c_fields-year.
        unit = 'JHR'.
      WHEN OTHERS.
        RAISE EXCEPTION TYPE cx_parameter_invalid_range
          EXPORTING
            parameter = 'PI_FIELD'
            value     = CONV #( iv_field )
            textid    = cx_parameter_invalid_range=>cx_parameter_invalid_range.
    ENDCASE.

    CONVERT DATE me->m_date TIME me->m_time
        INTO TIME STAMP DATA(ts) TIME ZONE c_utc.

    CALL FUNCTION 'TIMESTAMP_DURATION_ADD'
      EXPORTING
        timestamp_in    = ts
        timezone        = c_utc
        duration        = iv_value
        unit            = unit
      IMPORTING
        timestamp_out   = ts
      EXCEPTIONS
        timestamp_error = 1
        OTHERS          = 2.

    IF sy-subrc <> 0.
      ##FIXME.
    ENDIF.

    CONVERT TIME STAMP ts TIME ZONE c_utc
      INTO DATE me->m_date
           TIME me->m_time.

    ro_datetime = me.

  ENDMETHOD.


  METHOD add_days.

    ro_datetime = me->add( iv_field = c_fields-day
                             iv_value = iv_value ).

  ENDMETHOD.


  METHOD add_hours.

    ro_datetime = me->add( iv_field = c_fields-hour
                             iv_value = iv_value ).

  ENDMETHOD.


  METHOD add_minutes.

    ro_datetime = me->add( iv_field = c_fields-minute
                             iv_value = iv_value ).

  ENDMETHOD.


  METHOD add_months.

    ro_datetime = me->add( iv_field = c_fields-month
                             iv_value = iv_value ).

  ENDMETHOD.


  METHOD add_seconds.

    ro_datetime = me->add( iv_field = c_fields-second
                             iv_value = iv_value ).

  ENDMETHOD.


  METHOD add_weeks.

    ro_datetime = me->add( iv_field = c_fields-week
                             iv_value = iv_value ).

  ENDMETHOD.


  METHOD add_years.

    ro_datetime = me->add( iv_field = c_fields-year
                             iv_value = iv_value ).

  ENDMETHOD.


  METHOD as_date.

    rv_date = me->m_date.

  ENDMETHOD.


  METHOD as_iso_timestamp.

    CONVERT DATE me->m_date TIME me->m_time
     INTO TIME STAMP DATA(ts) TIME ZONE c_utc.

    rv_iso_timestamp = cl_xlf_date_time=>create( ts ).
  ENDMETHOD.


  METHOD as_long_timestamp.

    CONVERT DATE me->m_date TIME me->m_time
            INTO TIME STAMP rv_timestamp TIME ZONE c_utc.

  ENDMETHOD.


  METHOD as_timestamp.

    CONVERT DATE me->m_date TIME me->m_time
            INTO TIME STAMP rv_timestamp TIME ZONE c_utc.

  ENDMETHOD.


  METHOD begin_of_day.

    me->m_time = c_times-begin_of_day.

    ro_datetime = me.

  ENDMETHOD.


  METHOD begin_of_month.

    me->m_date+6(2) = '01'.

    ro_datetime = me.

  ENDMETHOD.


  METHOD begin_of_quarter.

    DATA(quarter) = me->get_quarter( ).

    CASE quarter.
      WHEN 1.
        me->m_date+4(4) = '0101'. ##FIXME.
      WHEN 2.
        me->m_date+4(4) = '0401'.
      WHEN 3.
        me->m_date+4(4) = '0701'.
      WHEN 4.
        me->m_date+4(4) = '1001'.
    ENDCASE.

    ro_datetime = me.

  ENDMETHOD.


  METHOD begin_of_week.

    DATA(current_dow) = me->get_day_of_week( ).

    me->m_date = me->m_date - ( current_dow - 1 ).

    ro_datetime = me.

  ENDMETHOD.


  METHOD begin_of_year.

    me->m_date+4(4) = c_day_of_year-first.

    ro_datetime = me.

  ENDMETHOD.


  METHOD clone.

    ro_clone = NEW #( ).

    ro_clone->m_date = me->m_date.
    ro_clone->m_time = me->m_time.

  ENDMETHOD.


  METHOD create_list.

    CASE iv_increment_field.
      WHEN c_fields-day.
      WHEN c_fields-hour.
      WHEN c_fields-month.
      WHEN c_fields-minute.
      WHEN c_fields-second.
      WHEN c_fields-week.
      WHEN c_fields-year.
      WHEN OTHERS.
        RAISE EXCEPTION TYPE cx_parameter_invalid_range
          EXPORTING
            parameter = 'PI_INCREMENT_FIELD'
            value     = CONV #( iv_increment_field )
            textid    = cx_parameter_invalid_range=>cx_parameter_invalid_range.
    ENDCASE.

    IF iv_increment_value <= 0.
      RAISE EXCEPTION TYPE cx_parameter_invalid_range
        EXPORTING
          parameter = 'PI_INCREMENT_VALUE'
          value     = CONV #( iv_increment_value )
          textid    = cx_parameter_invalid_range=>cx_parameter_invalid_range.
    ENDIF.

    IF iv_num_of_elements < 1.
      RAISE EXCEPTION TYPE cx_parameter_invalid_range
        EXPORTING
          parameter = 'PI_NUM_OF_ELEMENTS'
          value     = CONV #( iv_num_of_elements )
          textid    = cx_parameter_invalid_range=>cx_parameter_invalid_range.
    ENDIF.

    DATA: loop_count TYPE i VALUE 0.

    DATA(o_current) = io_start->clone( ).

    APPEND INITIAL LINE TO rt_datetime_list ASSIGNING FIELD-SYMBOL(<wa_datetime>).
    <wa_datetime>-o_datetime = o_current.

    o_current = o_current->clone( ).
    loop_count = loop_count + 1.

    WHILE loop_count < iv_num_of_elements.

      o_current->add( iv_field = iv_increment_field
                      iv_value = iv_increment_value ).

      APPEND INITIAL LINE TO rt_datetime_list ASSIGNING <wa_datetime>.
      <wa_datetime>-o_datetime = o_current.

      o_current = o_current->clone( ).

      loop_count = loop_count + 1.

    ENDWHILE.

  ENDMETHOD.


  METHOD day_of_week.

    DATA: current_day_of_week TYPE p,
          delta_in_days       TYPE ty_day_of_week.

    CASE pi_day_of_week.
      WHEN c_day_of_week-monday.
      WHEN c_day_of_week-tuesday.
      WHEN c_day_of_week-wednesday.
      WHEN c_day_of_week-thursday.
      WHEN c_day_of_week-friday.
      WHEN c_day_of_week-sunday.
      WHEN c_day_of_week-saturday.
      WHEN OTHERS.
        RAISE EXCEPTION TYPE cx_parameter_invalid_range
          EXPORTING
            parameter = 'PI_DAY_OF_WEEK'
            value     = CONV #( pi_day_of_week )
            textid    = cx_parameter_invalid_range=>cx_parameter_invalid_range.
    ENDCASE.

    current_day_of_week = me->get_day_of_week( ).

    delta_in_days = pi_day_of_week - current_day_of_week.

    me->add( iv_field = c_fields-day
             iv_value = delta_in_days ).

    pr_o_datetime = me.

  ENDMETHOD.


  METHOD diff.

    min_max( EXPORTING io_datetime_01 = me
                       io_datetime_02 = io_datetime
             IMPORTING eo_min_datetime = DATA(o_min)
                       eo_max_datetime = DATA(o_max) ).

    DATA(diff) = cl_abap_tstmp=>subtract( tstmp1 = CONV #( o_max->as_timestamp( ) )
                                          tstmp2 = CONV #( o_min->as_timestamp( ) ) ).

    CASE iv_field.
      WHEN c_fields-day.
        rv_diff = CONV #( diff / c_time_constants-num_seconds_per_day ).
      WHEN c_fields-hour.
        rv_diff = CONV #( diff / c_time_constants-num_seconds_per_hour ).
      WHEN c_fields-minute.
        rv_diff = CONV #( diff / c_time_constants-num_seconds_per_minute ).
      WHEN c_fields-week.
        rv_diff = CONV #( diff / c_time_constants-num_seconds_per_week ).
      WHEN c_fields-year.
        rv_diff = CONV #( diff / c_time_constants-num_seconds_per_year ).
      WHEN c_fields-second.
        rv_diff = diff.
      WHEN c_fields-month.

        IF o_min->is_equal( o_max ).
          rv_diff = 0.
        ELSE.

          DATA(min_year_month)  = ( o_min->get_year( ) * 100 ) + o_min->get_month( ).
          DATA(max_year_month) = ( o_max->get_year( ) * 100 ) + o_max->get_month( ).

          DATA(delta_year_month) = CONV f( max_year_month - min_year_month ).

          DATA(min_ultimo) = o_min->get_ultimo( ).
          DATA(max_ultimo) = o_max->get_ultimo( ).

          DATA(days_om_min) = CONV f( 1 / o_min->get_number_of_days_of_month( ) ).
          DATA(days_om_max) = CONV f( 1 / o_max->get_number_of_days_of_month( ) ).

          DATA(min_day_offset) = days_om_min * ( o_min->get_day_of_month( ) - 1 ). "" start day is included
          DATA(max_day_offset) = days_om_max * o_max->get_day_of_month( ).

          DATA(month_offset) = CONV f( min_day_offset  /  ( 1 / max_day_offset ) ).

          rv_diff = CONV #( delta_year_month + ( max_day_offset - min_day_offset ) ).

        ENDIF.

      WHEN OTHERS.
        RAISE EXCEPTION TYPE cx_parameter_invalid_range
          EXPORTING
            parameter = 'PI_FIELD'
            value     = CONV #( iv_field )
            textid    = cx_parameter_invalid_range=>cx_parameter_invalid_range.
    ENDCASE.

    IF iv_round_mode NE c_rouding-round_nothing.

      rv_diff = round( val  = rv_diff
                       dec  = iv_round_decimals
                       mode = iv_round_mode ).

    ENDIF.

  ENDMETHOD.


  METHOD end_of_day.

    me->m_time = c_times-end_of_day.

    ro_datetime = me.

  ENDMETHOD.


  METHOD end_of_month.

    DATA(last_of_month) = 0.

    DATA(month) = me->get_month( ).

    CASE month.
      WHEN c_month-january OR
           c_month-march   OR
           c_month-may     OR
           c_month-july    OR
           c_month-august  OR
           c_month-october OR
           c_month-december.
        last_of_month = 31.                              ""#EC NUMBER_OK
      WHEN c_month-february.
        "" brute check for leap year...
        IF me->is_leap_year( ) = abap_true.
          last_of_month = 29.                            ""#EC NUMBER_OK
        ELSE.
          last_of_month = 28.                            ""#EC NUMBER_OK
        ENDIF.
      WHEN OTHERS.
        last_of_month = 30.                              ""#EC NUMBER_OK
    ENDCASE.

    me->set( iv_field = c_fields-day
             iv_value = last_of_month ).

    ro_datetime = me.

  ENDMETHOD.


  METHOD end_of_quarter.

    ##TODO. "" Repository Github A. Teubner
    ##TODO. "" Namensraum prüfen.
    ##TODO. "" Abhängigkeiten reduzieren.
    ##TODO. "" Eigenes Paket.

    DATA(quarter) = me->get_quarter( ).

    CASE quarter.
      WHEN 1.
        me->m_date+4(4) = '0331'.
      WHEN 2.
        me->m_date+4(4) = '0630'.
      WHEN 3.
        me->m_date+4(4) = '0930'.
      WHEN 4.
        me->m_date+4(4) = '1231'.
    ENDCASE.

    ro_datetime = me.

  ENDMETHOD.


  METHOD end_of_week.

    ro_datetime = me.

    DATA(current_dow) = me->get_day_of_week( ).

    me->m_date = me->m_date + ( c_day_of_week-sunday - current_dow ).

    ro_datetime = me.

  ENDMETHOD.


  METHOD end_of_year.

    me->m_date+4(4) = c_day_of_year-last.

    ro_datetime = me.

    ro_datetime = me.

  ENDMETHOD.


  METHOD first_calendar_week.

    DATA(o_date) = me->clone( )->begin_of_year( ).

    DATA(first_day_of_year) = o_date->get_day_of_week( ).

    "" Die erste Kalenderwoche eine Jahres, ist die erste Woche,
    "" die mindestens vier Tage des neuen Jahre umfasst. Sprich
    "" der Erste eines Jahres muss vor dem Freitag liegen.
    IF first_day_of_year > c_day_of_week-thursday.
      me->m_date = o_date->begin_of_week( )->as_date( ).
    ELSE.
      me->m_date = o_date->begin_of_week(
                               )->add_weeks( 1
                               )->as_date( ).
    ENDIF.

    ro_datetime = me.

  ENDMETHOD.


  METHOD from_date.

    "" sanity check if date is out of bounds.
    "" e.g. 29th february of a none leap year.
    IF CONV i( CONV d( iv_date ) ) = 0.
      RAISE EXCEPTION TYPE cx_parameter_invalid_range
        EXPORTING
          parameter = 'PI_DATE'
          value     = CONV #( iv_date )
          textid    = cx_parameter_invalid_range=>cx_parameter_invalid_range.
    ENDIF.

    "" sanity check if time is out of bounds.
    IF iv_time IS SUPPLIED AND iv_time NOT BETWEEN c_times-begin_of_day AND c_times-end_of_day.
      RAISE EXCEPTION TYPE cx_parameter_invalid_range
        EXPORTING
          parameter = 'PI_TIME'
          value     = CONV #( iv_time )
          textid    = cx_parameter_invalid_range=>cx_parameter_invalid_range.
    ENDIF.

    ro_datetime = NEW #( ).

    ro_datetime->m_date = CONV #( iv_date ).
    ro_datetime->m_time = iv_time.


  ENDMETHOD.


  METHOD from_iso_timestamp.

    DATA(ts) = cl_xlf_date_time=>parse( iv_iso8601 ).

    ro_datetime = NEW #( ).

    CONVERT TIME STAMP ts TIME ZONE c_utc
      INTO DATE ro_datetime->m_date
      TIME ro_datetime->m_time.

  ENDMETHOD.


  METHOD from_long_timestamp.

    ro_datetime = NEW #( ).

    CONVERT TIME STAMP iv_ts TIME ZONE c_utc
      INTO DATE ro_datetime->m_date
      TIME ro_datetime->m_time.

  ENDMETHOD.


  METHOD from_now.

    "" Get current date and time...
    GET TIME STAMP FIELD DATA(ts).

    ro_datetime = NEW #( ).

    CONVERT TIME STAMP ts TIME ZONE sy-zonlo
      INTO DATE ro_datetime->m_date
      TIME ro_datetime->m_time.

  ENDMETHOD.


  METHOD from_timestamp.

    pr_o_datetime = NEW #( ).

    CONVERT TIME STAMP iv_ts TIME ZONE c_utc
      INTO DATE pr_o_datetime->m_date
      TIME pr_o_datetime->m_time.

  ENDMETHOD.


  METHOD from_today.

    ro_datetime = NEW #( ).

    ro_datetime->m_date = sy-datum.
    ro_datetime->m_time = c_times-begin_of_day.

  ENDMETHOD.


  METHOD get_century.

    rv_century = CONV i( m_date+0(4) ) DIV 100.

  ENDMETHOD.


  METHOD get_dayname.

    DATA: weekday TYPE dtresr-weekday.
    CALL FUNCTION 'DATE_TO_DAY'
      EXPORTING
        date    = me->m_date
      IMPORTING
        weekday = weekday.

    rv_dayname = weekday.

  ENDMETHOD.


  METHOD get_day_of_month.

    rv_day_of_month = m_date+6(2).

  ENDMETHOD.


  METHOD get_day_of_week.

    DATA(gd) = me->get_gregorian_day( ).

    DATA(mod_gd) = gd MOD 7.

    CASE mod_gd.
      WHEN 0. rv_day_of_week = c_day_of_week-friday.
      WHEN 1. rv_day_of_week = c_day_of_week-saturday.
      WHEN 2. rv_day_of_week = c_day_of_week-sunday.
      WHEN 3. rv_day_of_week = c_day_of_week-monday.
      WHEN 4. rv_day_of_week = c_day_of_week-tuesday.
      WHEN 5. rv_day_of_week = c_day_of_week-wednesday.
      WHEN 6. rv_day_of_week = c_day_of_week-thursday.
    ENDCASE.


  ENDMETHOD.


  METHOD get_day_of_year.

    DATA(first_day) = me->clone( )->begin_of_year( )->as_date( ).

    rv_day_of_year = me->m_date - first_day  + 1.

  ENDMETHOD.


  METHOD get_doom_day.

    rv_doom_day = me->clone(
                    )->begin_of_year(
                    )->add_years( iv_year_offset
                    )->get_day_of_week( ).

  ENDMETHOD.


  METHOD get_gregorian_day.

    CONSTANTS: c_first_day_ad TYPE dats VALUE '00010101'.

    rv_gregorian_day = me->m_date - c_first_day_ad + 1.

  ENDMETHOD.


  METHOD get_iso_week.

    DATA(base_week)           = 0.
    DATA(base_year)           = me->get_year( ).
    DATA(first_dow_this_year) = me->get_doom_day(    ).
    DATA(first_dow_last_year) = me->get_doom_day( -1 ).
    DATA(first_dow_next_year) = me->get_doom_day(  1 ).


    DATA(day_of_year) = me->get_day_of_year( ) - 1.

    IF first_dow_this_year > c_day_of_week-thursday.
      day_of_year = day_of_year  - ( 7 - first_dow_this_year ).
    ELSE.
      day_of_year = day_of_year  + first_dow_this_year.
    ENDIF.

    IF day_of_year < 0.
      IF first_dow_this_year = c_day_of_week-friday OR
            first_dow_last_year = c_day_of_week-thursday.
        base_week = 53.
      ELSE.
        base_week = 52.
      ENDIF.
      base_year = base_year - 1.
    ELSE.
      base_week = ( day_of_year DIV 7 ) + 1.
    ENDIF.

    IF day_of_year > 360 AND base_week > 52.
      IF first_dow_this_year = c_day_of_week-thursday.
        base_week = 53.
      ELSEIF first_dow_next_year = c_day_of_week-friday.
        base_week = 53.
      ELSE.
        base_week = 1.
        base_year = base_year + 1.
      ENDIF.
    ENDIF.

    rs_iso_week-week        = base_week.
    rs_iso_week-year        = base_year.
    rs_iso_week-day_of_week = me->get_day_of_week( ).

  ENDMETHOD.


  METHOD get_month.

    rv_month = m_date+4(2).

  ENDMETHOD.


  METHOD get_number_of_days_of_month.

    DATA(ultimo) = me->get_ultimo( ).
    rv_number_of_days_of_month =  ultimo+6(2).

  ENDMETHOD.


  METHOD get_number_of_days_of_year.

    IF me->is_leap_year( ) = abap_true.
      rv_number_of_days_of_year =  c_day_of_year-max_days_in_leap_year.
    ELSE.
      rv_number_of_days_of_year =  c_day_of_year-max_days_in_none_leap_year.
    ENDIF.

  ENDMETHOD.


  METHOD get_quarter.

    DATA(month) = me->get_month( ).

    DATA(quarter) = CONV f( month / 3 ).

    rv_quarter = round( val = quarter dec = 0 mode = cl_abap_math=>round_ceiling ) .

  ENDMETHOD.


  METHOD get_ultimo.

    DATA(month) = me->get_month( ).

    CASE month.
      WHEN c_month-january  OR
           c_month-march    OR
           c_month-may      OR
           c_month-july     OR
           c_month-august   OR
           c_month-october  OR
           c_month-december.
        rv_last_day_of_month    = me->m_date+0(6) && 31.
      WHEN c_month-february.
        IF me->is_leap_year( ) = abap_true.
          rv_last_day_of_month  = me->m_date+0(6) && 29.
        ELSE.
          rv_last_day_of_month  = me->m_date+0(6) && 28.
        ENDIF.
      WHEN OTHERS.
        rv_last_day_of_month    = me->m_date+0(6) && 30.
    ENDCASE.

  ENDMETHOD.


  METHOD get_year.

    rv_year = m_date+0(4).

  ENDMETHOD.


  METHOD is_after.

    DATA(this_ts)  = CONV ty_ts_string( me->as_timestamp( ) ).
    DATA(other_ts) = CONV ty_ts_string( io_datetime->as_timestamp( ) ).

    "" Transient time...
    IF iv_ignore_time = abap_true.
      this_ts+8(6)  = c_times-begin_of_day.
      other_ts+8(6) = c_times-begin_of_day.
    ENDIF.

    IF this_ts > other_ts.
      pr_is_after =  abap_true.
    ELSE.
      pr_is_after =  abap_false.
    ENDIF.

  ENDMETHOD.


  METHOD is_after_or_equal.

    DATA(this_ts)  = CONV ty_ts_string( me->as_timestamp( ) ).
    DATA(other_ts) = CONV ty_ts_string( io_datetime->as_timestamp( ) ).

    "" Transient time...
    IF iv_ignore_time = abap_true.
      this_ts+8(6)  = c_times-begin_of_day.
      other_ts+8(6) = c_times-begin_of_day.
    ENDIF.

    IF this_ts >= other_ts.
      pr_is_after_or_equal =  abap_true.
    ELSE.
      pr_is_after_or_equal =  abap_false.
    ENDIF.

  ENDMETHOD.


  METHOD is_before.

    DATA(this_ts)  = CONV ty_ts_string( me->as_timestamp( ) ).
    DATA(other_ts) = CONV ty_ts_string( io_datetime->as_timestamp( ) ).

    "" Transient time...
    IF iv_ignore_time = abap_true.
      this_ts+8(6)  = c_times-begin_of_day.
      other_ts+8(6) = c_times-begin_of_day.
    ENDIF.

    IF this_ts < other_ts.
      rv_is_before =  abap_true.
    ELSE.
      rv_is_before =  abap_false.
    ENDIF.


  ENDMETHOD.


  METHOD is_before_or_equal.

    DATA(this_ts)  = CONV ty_ts_string( me->as_timestamp( ) ).
    DATA(other_ts) = CONV ty_ts_string( io_datetime->as_timestamp( ) ).

    "" Transient time...
    IF iv_ignore_time = abap_true.
      this_ts+8(6)  = c_times-begin_of_day.
      other_ts+8(6) = c_times-begin_of_day.
    ENDIF.

    IF this_ts <= other_ts.
      rv_is_before_or_equal =  abap_true.
    ELSE.
      rv_is_before_or_equal =  abap_false.
    ENDIF.

  ENDMETHOD.


  METHOD is_equal.

    DATA(this_ts)  = CONV ty_ts_string( me->as_timestamp( ) ).
    DATA(other_ts) = CONV ty_ts_string( io_datetime->as_timestamp( ) ).

    "" Transient time...
    IF iv_ignore_time = abap_true.
      this_ts+8(6)  = c_times-begin_of_day.
      other_ts+8(6) = c_times-begin_of_day.
    ENDIF.

    IF this_ts = other_ts.
      rv_is_before =  abap_true.
    ELSE.
      rv_is_before =  abap_false.
    ENDIF.


  ENDMETHOD.


  METHOD is_last_day_of_month.

    DATA(last_day_of_month) = me->get_ultimo( ).

    rv_is_last_day_of_month = COND #( WHEN me->m_date = last_day_of_month
                                            THEN  abap_true
                                            ELSE  abap_false ).

  ENDMETHOD.


  METHOD is_leap_year.

    DATA(year) = me->get_year( ).

    DATA(mod_4)   = year MOD 4.
    DATA(mod_100) = year MOD 100.
    DATA(mod_400) = year MOD 400.

    IF mod_4 = 0 AND mod_100 NE 0.
      rv_is_leap = abap_true.
    ELSEIF mod_400 = 0.
      rv_is_leap = abap_true.
    ENDIF.

  ENDMETHOD.


  METHOD max.

    IF io_datetime_01->is_equal( io_datetime = io_datetime_02 iv_ignore_time = iv_ignore_time ).
      ro_max = io_datetime_01.
      RETURN.
    ENDIF.

    IF io_datetime_01->is_before( io_datetime = io_datetime_02 iv_ignore_time = iv_ignore_time ).
      ro_max = io_datetime_01.
      RETURN.
    ELSE.
      ro_max = io_datetime_02.
      RETURN.
    ENDIF.



  ENDMETHOD.


  METHOD min.

    IF io_datetime_01->is_equal( io_datetime = io_datetime_02 iv_ignore_time = iv_ignore_time ).
      ro_min = io_datetime_02.
      RETURN.
    ENDIF.

    IF io_datetime_01->is_before( io_datetime = io_datetime_02 iv_ignore_time = iv_ignore_time ).
      ro_min = io_datetime_02.
      RETURN.
    ELSE.
      ro_min = io_datetime_01.
      RETURN.
    ENDIF.



  ENDMETHOD.


  METHOD min_max.

    IF io_datetime_01->is_equal( io_datetime = io_datetime_02 iv_ignore_time = iv_ignore_time ).
      eo_min_datetime = io_datetime_01.
      eo_max_datetime = io_datetime_02.
      RETURN.
    ENDIF.

    IF io_datetime_01->is_before( io_datetime = io_datetime_02 iv_ignore_time = iv_ignore_time ).
      eo_min_datetime = io_datetime_01.
      eo_max_datetime = io_datetime_02.
      RETURN.
    ENDIF.

    eo_min_datetime = io_datetime_02.
    eo_max_datetime = io_datetime_01.

  ENDMETHOD.


  METHOD set.

    ro_datetime = me.

    CASE iv_field.
      WHEN c_fields-second.
        IF iv_value < 0 OR iv_value > 59.
          RETURN.
        ENDIF.
        me->m_time+4(2) = |{ iv_value WIDTH = 2 PAD = '0' ALIGN = RIGHT }|.
      WHEN c_fields-minute.
        IF iv_value < 0 OR iv_value > 60.
          RETURN.
        ENDIF.
        me->m_time+2(2) = |{ iv_value WIDTH = 2 PAD = '0' ALIGN = RIGHT }|.
      WHEN c_fields-hour.
        IF iv_value < 0 OR iv_value > 23.
          RETURN.
        ENDIF.
        me->m_time+0(2) = |{ iv_value WIDTH = 2 PAD = '0' ALIGN = RIGHT }|.
      WHEN c_fields-day.
        DATA(number_of_days_in_month) = me->get_number_of_days_of_month( ).
        IF iv_value < 0 OR iv_value > number_of_days_in_month.
          RETURN.
        ENDIF.
        me->m_date+6(2) = |{ iv_value WIDTH = 2 PAD = '0' ALIGN = RIGHT }|.
      WHEN c_fields-month.
        IF iv_value < 1 OR iv_value > 12.
          RETURN.
        ENDIF.
        me->m_date+4(2) = |{ iv_value WIDTH = 2 PAD = '0' ALIGN = RIGHT }|.
      WHEN c_fields-year.
        IF iv_value < 0 OR iv_value > 9999.
          RETURN.
        ENDIF.
        me->m_date+0(4) = |{ iv_value WIDTH = 4 PAD = '0' ALIGN = RIGHT }|.
      WHEN c_fields-week.
        IF iv_value < 1 OR iv_value > 53.
          RETURN.
        ENDIF.
        DATA(new_date) = me->clone(
                                )->begin_of_year(
                                )->add_weeks( iv_value
                                )->begin_of_week(
                                )->add_days( me->get_day_of_week( ) - 1
                                )->as_date( ).
        me->m_date = new_date.
    ENDCASE.

  ENDMETHOD.


  METHOD subtract.

    iv_value = iv_value * -1.

    ro_datetime = me->add( iv_field = iv_field
                             iv_value = iv_value ).

  ENDMETHOD.


  METHOD sub_days.

    ro_datetime = me->add( iv_field = c_fields-day
                             iv_value = iv_value * -1 ).

  ENDMETHOD.


  METHOD sub_hours.

    ro_datetime = me->add( iv_field = c_fields-hour
                             iv_value = iv_value * -1 ).

  ENDMETHOD.


  METHOD sub_minutes.

    ro_datetime = me->add( iv_field = c_fields-minute
                             iv_value = iv_value * -1 ).

  ENDMETHOD.


  METHOD sub_months.

    ro_datetime = me->add( iv_field = c_fields-month
                             iv_value = iv_value * -1 ).

  ENDMETHOD.


  METHOD sub_seconds.

    ro_datetime = me->add( iv_field = c_fields-second
                             iv_value = iv_value * -1 ).

  ENDMETHOD.


  METHOD sub_weeks.

    ro_datetime = me->add( iv_field = c_fields-week
                             iv_value = iv_value * -1 ).

  ENDMETHOD.


  METHOD sub_years.

    ro_datetime = me->add( iv_field = c_fields-year
                             iv_value = iv_value * -1 ).

  ENDMETHOD.
ENDCLASS.
",15138,True,2594.6621585822713,median
"CLASS zcl_abap2xlsx_helper_int DEFINITION
  PUBLIC
  CREATE PUBLIC .

  PUBLIC SECTION.

    CLASS-METHODS excel_download
      IMPORTING
        !it_data                 TYPE STANDARD TABLE
        !it_field                TYPE zcl_abap2xlsx_helper=>tt_field OPTIONAL
        !iv_filename             TYPE clike OPTIONAL
        !iv_sheet_title          TYPE clike OPTIONAL
        !iv_image_xstring        TYPE xstring OPTIONAL
        !iv_add_fixedvalue_sheet TYPE flag DEFAULT abap_true
        !iv_auto_column_width    TYPE flag DEFAULT abap_true
        !iv_default_descr        TYPE c DEFAULT 'L'
      EXPORTING
        !ev_excel                TYPE xstring
        !ev_error_text           TYPE string .
    CLASS-METHODS excel_email
      IMPORTING
        !it_data                 TYPE STANDARD TABLE
        !it_field                TYPE zcl_abap2xlsx_helper=>tt_field OPTIONAL
        !iv_subject              TYPE clike OPTIONAL
        !iv_sender               TYPE clike OPTIONAL
        !it_receiver             TYPE stringtab OPTIONAL
        !iv_filename             TYPE clike OPTIONAL
        !iv_sheet_title          TYPE clike OPTIONAL
        !iv_image_xstring        TYPE xstring OPTIONAL
        !iv_add_fixedvalue_sheet TYPE flag DEFAULT abap_true
        !iv_auto_column_width    TYPE flag DEFAULT abap_true
        !iv_default_descr        TYPE c DEFAULT 'L' .
    CLASS-METHODS excel_upload
      IMPORTING
        !iv_excel      TYPE xstring OPTIONAL
        !it_field      TYPE zcl_abap2xlsx_helper=>tt_field OPTIONAL
        !iv_begin_row  TYPE int4 DEFAULT 2
        !iv_sheet_no   TYPE int1 DEFAULT 1
      EXPORTING
        !et_data       TYPE STANDARD TABLE
        !ev_error_text TYPE string .
    CLASS-METHODS get_fieldcatalog
      IMPORTING
        !it_data          TYPE STANDARD TABLE
        !iv_default_descr TYPE c DEFAULT 'L'
      EXPORTING
        !et_field         TYPE zcl_abap2xlsx_helper=>tt_field .
    CLASS-METHODS convert_abap_to_excel
      IMPORTING
        !it_data                 TYPE STANDARD TABLE
        !it_ddic_object          TYPE dd_x031l_table OPTIONAL
        !it_field                TYPE zcl_abap2xlsx_helper=>tt_field OPTIONAL
        !iv_sheet_title          TYPE clike OPTIONAL
        !iv_image_xstring        TYPE xstring OPTIONAL
        !iv_add_fixedvalue_sheet TYPE flag DEFAULT abap_true
        !iv_auto_column_width    TYPE flag DEFAULT abap_true
        !iv_default_descr        TYPE c DEFAULT 'L'
      EXPORTING
        !ev_excel                TYPE xstring
        !ev_error_text           TYPE string .
    CLASS-METHODS convert_json_to_excel
      IMPORTING
        !iv_data_json            TYPE string
        !it_ddic_object          TYPE dd_x031l_table
        !it_field                TYPE zcl_abap2xlsx_helper=>tt_field
        !iv_sheet_title          TYPE clike OPTIONAL
        !iv_image_xstring        TYPE xstring OPTIONAL
        !iv_add_fixedvalue_sheet TYPE flag DEFAULT abap_true
        !iv_auto_column_width    TYPE flag DEFAULT abap_true
        !iv_default_descr        TYPE c DEFAULT 'L'
      EXPORTING
        !ev_excel                TYPE xstring
        !ev_error_text           TYPE string .
    CLASS-METHODS convert_excel_to_abap
      IMPORTING
        !iv_excel      TYPE xstring
        !it_field      TYPE zcl_abap2xlsx_helper=>tt_field OPTIONAL
        !iv_begin_row  TYPE int4 DEFAULT 2
        !iv_sheet_no   TYPE int1 DEFAULT 1
      EXPORTING
        !et_data       TYPE STANDARD TABLE
        !ev_error_text TYPE string .
    CLASS-METHODS get_xstring_from_smw0
      IMPORTING
        !iv_smw0          TYPE wwwdata-objid
      RETURNING
        VALUE(rv_xstring) TYPE xstring .
  PROTECTED SECTION.

    CLASS-METHODS start_download
      IMPORTING
        !iv_excel    TYPE xstring
        !iv_filename TYPE clike OPTIONAL .
    CLASS-METHODS start_upload
      EXPORTING
        !ev_excel TYPE xstring .
    CLASS-METHODS do_drm_encode
      CHANGING
        !cv_excel TYPE xstring .
    CLASS-METHODS do_drm_decode
      CHANGING
        !cv_excel TYPE xstring .
    CLASS-METHODS add_fixedvalue_sheet
      IMPORTING
        !it_data             TYPE STANDARD TABLE
        !it_field            TYPE zcl_abap2xlsx_helper=>tt_field
        !it_field_catalog    TYPE zexcel_t_fieldcatalog
        !io_excel            TYPE REF TO zcl_excel
        !iv_worksheet_index  TYPE i DEFAULT 1
        !iv_header_row_index TYPE i DEFAULT 1
      RAISING
        zcx_excel .
    CLASS-METHODS add_image
      IMPORTING
        !iv_image_xstring   TYPE xstring
        !iv_col             TYPE i
        !io_excel           TYPE REF TO zcl_excel
        !iv_worksheet_index TYPE i DEFAULT 1
      RAISING
        zcx_excel .
    CLASS-METHODS get_ddic_object
      IMPORTING
        !i_data               TYPE data
      RETURNING
        VALUE(rt_ddic_object) TYPE dd_x031l_table .
  PRIVATE SECTION.
ENDCLASS.



CLASS ZCL_ABAP2XLSX_HELPER_INT IMPLEMENTATION.


  METHOD add_fixedvalue_sheet.
* http://www.abap2xlsx.org
    DATA: lo_worksheet       TYPE REF TO zcl_excel_worksheet,
          lo_worksheet_fv    TYPE REF TO zcl_excel_worksheet,
          lo_data_validation TYPE REF TO zcl_excel_data_validation,
          ls_field_catalog   TYPE zexcel_s_fieldcatalog,
          ls_field           TYPE za2xh_s_fieldcatalog,
          lv_sheet_title_fv  TYPE zexcel_sheet_title,
          lt_comp_view       TYPE abap_component_view_tab,
          ls_comp_view       TYPE abap_simple_componentdescr,
          lt_fixed_value     TYPE ddfixvalues,
          ls_fixed_value     TYPE ddfixvalue,
          lt_ddl             TYPE wdr_context_attr_value_list,
          ls_ddl             TYPE wdr_context_attr_value,
          lv_cell_value	     TYPE zexcel_cell_value,
          lo_style_fv	       TYPE REF TO zcl_excel_style,
          lv_style_fv	       TYPE zexcel_cell_style,
          lv_lines_data      TYPE i,
          lv_lines_ddl       TYPE i,
          lv_index_col       TYPE i.

    lo_worksheet = io_excel->get_worksheet_by_index( iv_worksheet_index ).
    lv_lines_data = lines( it_data ).
    IF lv_lines_data EQ 0.
      lv_lines_data = 1.
    ENDIF.
    lv_lines_data = lv_lines_data + iv_header_row_index.

    lo_style_fv = io_excel->add_new_style( ).
    lo_style_fv->font->color-rgb = zcl_excel_style_color=>c_yellow.
    lv_style_fv = lo_style_fv->get_guid( ).

    CAST cl_abap_structdescr(
      CAST cl_abap_tabledescr(
        cl_abap_tabledescr=>describe_by_data( it_data )
      )->get_table_line_type( )
    )->get_included_view( RECEIVING p_result = lt_comp_view ).
    SORT lt_comp_view BY name.

    LOOP AT it_field_catalog INTO ls_field_catalog.
      lv_index_col = sy-tabix.
      CLEAR: lt_ddl.


      "" 1. get from it_field-fxied_values
      READ TABLE it_field INTO ls_field INDEX lv_index_col.
      IF sy-subrc EQ 0.
        lt_ddl = ls_field-fixed_values.
      ENDIF.

      "" 2. get from ddic domain fixed value
      IF lt_ddl IS INITIAL.
        READ TABLE lt_comp_view INTO ls_comp_view WITH KEY name = ls_field_catalog-fieldname BINARY SEARCH.
        lt_ddl = zcl_abap2xlsx_helper=>get_ddic_fixed_values( ls_comp_view-type ).
      ENDIF.

      CHECK: lt_ddl IS NOT INITIAL.
      lv_lines_ddl = lines( lt_ddl ) + 1.

      "" create fv-sheet
      lv_sheet_title_fv = ls_field_catalog-fieldname.
      lo_worksheet_fv = io_excel->get_worksheet_by_name( lv_sheet_title_fv ).
      IF lo_worksheet_fv IS INITIAL.
        lo_worksheet_fv = io_excel->add_new_worksheet( lv_sheet_title_fv ).
        lo_worksheet_fv->bind_table(
          EXPORTING
            ip_table          = lt_ddl
            it_field_catalog  = VALUE #(
                                  ( fieldname = 'VALUE' position = 1 scrtext_l = 'Value' dynpfld = abap_true )
                                  ( fieldname = 'TEXT' position = 2 scrtext_l = 'Text' dynpfld = abap_true )
                                )
        ).
        lo_worksheet_fv->zif_excel_sheet_protection~protected = lo_worksheet_fv->zif_excel_sheet_protection~c_protected.
        lo_worksheet_fv->zif_excel_sheet_protection~sheet = lo_worksheet_fv->zif_excel_sheet_protection~c_active.
        lo_worksheet_fv->zif_excel_sheet_protection~objects = lo_worksheet_fv->zif_excel_sheet_protection~c_active.
        IF lv_lines_ddl <= 3.
          "" If it has 1 or 2 fixed values, hide fv-sheet.
          lo_worksheet_fv->zif_excel_sheet_properties~hidden = lo_worksheet_fv->zif_excel_sheet_properties~c_hidden.
        ENDIF.
      ENDIF.

      "" add validation
      lo_data_validation = lo_worksheet->add_new_data_validation( ).
      lo_data_validation->type = zcl_excel_data_validation=>c_type_list.
      lo_data_validation->allowblank = abap_true.
      lo_data_validation->formula1 = lv_sheet_title_fv && '!$A$2:$A$' && lv_lines_ddl.
      lo_data_validation->cell_column = zcl_excel_common=>convert_column2alpha( lv_index_col ).
      lo_data_validation->cell_column_to = lo_data_validation->cell_column.
      lo_data_validation->cell_row = iv_header_row_index + 1.
      lo_data_validation->cell_row_to = lv_lines_data.

      IF iv_header_row_index IS NOT INITIAL AND lo_worksheet_fv->zif_excel_sheet_properties~hidden IS INITIAL.
        "" link to fv-sheet @ header
        lo_worksheet->get_cell(
          EXPORTING
            ip_column  = lo_data_validation->cell_column
            ip_row     = iv_header_row_index
          IMPORTING
            ep_value   = lv_cell_value
        ).
        lo_worksheet->set_cell(
          EXPORTING
            ip_column    = lo_data_validation->cell_column
            ip_row       = iv_header_row_index
            ip_value     = lv_cell_value
            ip_style     = lv_style_fv
            ip_hyperlink = zcl_excel_hyperlink=>create_internal_link( lv_sheet_title_fv && '!A1' )
        ).
      ENDIF.

    ENDLOOP.

  ENDMETHOD.


  METHOD add_image.
* http://www.abap2xlsx.org
    DATA: lo_worksheet    TYPE REF TO zcl_excel_worksheet,
          lo_drawing      TYPE REF TO zcl_excel_drawing,
          lv_image_type   TYPE string,
          lv_image_width  TYPE i,
          lv_image_height TYPE i.


    cl_fxs_image_info=>determine_info(
      EXPORTING
        iv_data     = iv_image_xstring
      IMPORTING
        ev_mimetype = lv_image_type
        ev_xres     = lv_image_width
        ev_yres     = lv_image_height
    ).
    CASE lv_image_type.
      WHEN cl_fxs_mime_types=>co_image_bitmap.
        lv_image_type = 'BMP'.
      WHEN cl_fxs_mime_types=>co_image_png.
        lv_image_type = 'PNG'.
      WHEN cl_fxs_mime_types=>co_image_gif.
        lv_image_type = 'GIF'.
      WHEN cl_fxs_mime_types=>co_image_tiff.
        lv_image_type = 'TIF'.
      WHEN cl_fxs_mime_types=>co_image_jpeg.
        lv_image_type = 'JPG'.
      WHEN OTHERS.
        "" not supported.
        RETURN.
    ENDCASE.

    lo_worksheet = io_excel->get_worksheet_by_index( iv_worksheet_index ).
    lo_drawing = io_excel->add_new_drawing( ).

    lo_drawing->set_media(
      EXPORTING
        ip_media      = iv_image_xstring
        ip_media_type = lv_image_type
        ip_width      = lv_image_width
        ip_height     = lv_image_height
    ).
    lo_drawing->set_position(
      EXPORTING
        ip_from_row = 1
        ip_from_col = zcl_excel_common=>convert_column2alpha( iv_col )
    ).
    lo_worksheet->add_drawing( lo_drawing ).
  ENDMETHOD.


  METHOD convert_abap_to_excel.
* http://www.abap2xlsx.org
    DATA: lo_excel           TYPE REF TO zcl_excel,
          lo_writer          TYPE REF TO zif_excel_writer,
          lo_worksheet       TYPE REF TO zcl_excel_worksheet,
          ls_table_settings  TYPE zexcel_s_table_settings,
          lt_field_catalog   TYPE zexcel_t_fieldcatalog,
          lt_field_catalog2  TYPE zexcel_t_fieldcatalog,
          ls_field_catalog   TYPE zexcel_s_fieldcatalog,
          ls_field           TYPE za2xh_s_fieldcatalog,
          lo_zcx_excel       TYPE REF TO zcx_excel,
          lv_sheet_title     TYPE zexcel_sheet_title,
          lt_ddic_object     TYPE dd_x031l_table,
          ls_ddic_object     TYPE x031l,
          ls_ddic_object_ref TYPE x031l,
          lv_amount_external TYPE bapicurr-bapicurr,
          lr_data            TYPE REF TO data,
          lv_conversion      TYPE string,
          lv_local_ts        TYPE timestamp,
          lv_alpha_out       TYPE string,
          lv_index_col       TYPE i,
          lv_index           TYPE i.
    FIELD-SYMBOLS: <ls_data>     TYPE data,
                   <lv_data>     TYPE data,
                   <lv_data_ref> TYPE data.
    CLEAR ev_error_text.

    TRY.

        "" Creates active sheet
        CREATE OBJECT lo_excel.

        "" Get active sheet
        IF iv_sheet_title IS NOT INITIAL.
          lv_sheet_title = iv_sheet_title.
        ELSE.
          lv_sheet_title = 'Export'.
        ENDIF.
        lo_worksheet = lo_excel->get_active_worksheet( ).
        lo_worksheet->set_title( ip_title = lv_sheet_title ).

        "" table settings
        ls_table_settings-table_style       = zcl_excel_table=>builtinstyle_medium2.
        ls_table_settings-show_row_stripes  = abap_true.
        ls_table_settings-nofilters         = abap_false.

        "" field catalog
        lt_field_catalog = zcl_excel_common=>get_fieldcatalog( ip_table = it_data ).
        IF it_field IS NOT INITIAL.
          lt_field_catalog2 = lt_field_catalog.
          SORT lt_field_catalog2 BY fieldname.
          CLEAR: lt_field_catalog.

          IF it_ddic_object IS NOT INITIAL.
            LOOP AT it_ddic_object INTO ls_ddic_object.
              READ TABLE lt_field_catalog2 INTO ls_field_catalog WITH KEY fieldname = ls_ddic_object-fieldname BINARY SEARCH.
              IF sy-subrc EQ 0.
                lv_index = sy-tabix.
                ls_field_catalog-abap_type = ls_ddic_object-exid.
                MODIFY lt_field_catalog2 FROM ls_field_catalog INDEX lv_index TRANSPORTING abap_type.
              ENDIF.
            ENDLOOP.
          ENDIF.

          LOOP AT it_field INTO ls_field.
            lv_index = sy-tabix.
            READ TABLE lt_field_catalog2 INTO ls_field_catalog WITH KEY fieldname = ls_field-fieldname BINARY SEARCH.
            CHECK: sy-subrc EQ 0.
            ls_field_catalog-position = lv_index.
            ls_field_catalog-dynpfld = abap_true.
            IF ls_field-label_text IS NOT INITIAL.
              ls_field_catalog-scrtext_s = ls_field_catalog-scrtext_m = ls_field_catalog-scrtext_l = ls_field-label_text.
            ENDIF.
            APPEND ls_field_catalog TO lt_field_catalog.
          ENDLOOP.
        ENDIF.
        DELETE lt_field_catalog WHERE dynpfld NE abap_true.


**********************************************************************
        lo_worksheet->bind_table( ip_table          = it_data
                                  it_field_catalog  = lt_field_catalog
                                  is_table_settings = ls_table_settings ).
**********************************************************************

        "" conversion exit.
        CREATE DATA lr_data LIKE LINE OF it_data.
        ASSIGN lr_data->* TO <ls_data>.
        LOOP AT lt_field_catalog INTO ls_field_catalog.
          lv_index_col = sy-tabix.
          ASSIGN COMPONENT ls_field_catalog-fieldname OF STRUCTURE <ls_data> TO <lv_data>.
          DESCRIBE FIELD <lv_data> EDIT MASK lv_conversion.
          IF lv_conversion EQ '==TSTLC' OR
             lv_conversion EQ '==TSTPS'.
            LOOP AT it_data ASSIGNING <ls_data>.
              lv_index = sy-tabix + 1.
              ASSIGN COMPONENT ls_field_catalog-fieldname OF STRUCTURE <ls_data> TO <lv_data>.
              IF <lv_data> IS NOT INITIAL.
                IF lv_conversion EQ '==TSTLC'.
                  PERFORM convert_to_local_time IN PROGRAM saplsdc_cnv USING <lv_data> CHANGING lv_local_ts.
                ELSE.
                  lv_local_ts = <lv_data>.
                ENDIF.
                lo_worksheet->set_cell(
                  EXPORTING
                    ip_column    = lv_index_col
                    ip_row       = lv_index
                    ip_value     = lv_local_ts
                    ip_abap_type = cl_abap_typedescr=>typekind_char
                ).
              ENDIF.
            ENDLOOP.
          ELSEIF lv_conversion EQ '==ALPHA'.
            LOOP AT it_data ASSIGNING <ls_data>.
              lv_index = sy-tabix + 1.
              ASSIGN COMPONENT ls_field_catalog-fieldname OF STRUCTURE <ls_data> TO <lv_data>.
              IF <lv_data> IS NOT INITIAL.
                CALL FUNCTION 'CONVERSION_EXIT_ALPHA_OUTPUT'
                  EXPORTING
                    input  = <lv_data>
                  IMPORTING
                    output = lv_alpha_out.
                lo_worksheet->set_cell(
                  EXPORTING
                    ip_column    = lv_index_col
                    ip_row       = lv_index
                    ip_value     = lv_alpha_out
                    ip_abap_type = cl_abap_typedescr=>typekind_char
                ).
              ENDIF.
            ENDLOOP.
          ENDIF.
        ENDLOOP.

        "" currency
        IF it_ddic_object IS NOT INITIAL.
          lt_ddic_object = it_ddic_object.
        ELSE.
          lt_ddic_object = get_ddic_object( it_data ).
        ENDIF.
        LOOP AT lt_ddic_object INTO ls_ddic_object WHERE reffield IS NOT INITIAL.
          READ TABLE lt_field_catalog TRANSPORTING NO FIELDS WITH KEY fieldname = ls_ddic_object-fieldname.
          CHECK: sy-subrc EQ 0.
          lv_index_col = sy-tabix.
          READ TABLE lt_ddic_object INTO ls_ddic_object_ref WITH KEY fieldname = ls_ddic_object-reffield dtyp = 'CUKY'.
          CHECK: sy-subrc EQ 0.
          LOOP AT it_data ASSIGNING <ls_data>.
            lv_index = sy-tabix + 1.
            ASSIGN COMPONENT ls_ddic_object-fieldname OF STRUCTURE <ls_data> TO <lv_data>.
            ASSIGN COMPONENT ls_ddic_object_ref-fieldname OF STRUCTURE <ls_data> TO <lv_data_ref>.
            IF <lv_data> IS NOT INITIAL AND
               <lv_data_ref> IS NOT INITIAL AND
               <lv_data_ref> <> 'USD' AND
               <lv_data_ref> <> 'EUR'.
              CALL FUNCTION 'BAPI_CURRENCY_CONV_TO_EXTERNAL'
                EXPORTING
                  currency        = CONV tcurc-waers( <lv_data_ref> )
                  amount_internal = <lv_data>
                IMPORTING
                  amount_external = lv_amount_external.
              lo_worksheet->set_cell(
                EXPORTING
                  ip_column    = lv_index_col
                  ip_row       = lv_index
                  ip_value     = lv_amount_external
                  ip_abap_type = cl_abap_typedescr=>typekind_packed
              ).
            ENDIF.
          ENDLOOP.
        ENDLOOP.

        "" auto column width
        IF iv_auto_column_width EQ abap_true.
          lv_index = lines( lt_field_catalog ).
          DO lv_index TIMES.
            lo_worksheet->set_column_width(
              EXPORTING
                ip_column         = sy-index
                ip_width_autosize = abap_true
            ).
          ENDDO.
        ENDIF.

        "" add fixed value sheet
        IF iv_add_fixedvalue_sheet EQ abap_true.
          add_fixedvalue_sheet(
            EXPORTING
              it_data             = it_data
              it_field            = it_field
              it_field_catalog    = lt_field_catalog
              io_excel            = lo_excel
          ).
          lo_excel->set_active_sheet_index( 1 ).
        ENDIF.

        "" add image
        IF iv_image_xstring IS NOT INITIAL.
          add_image(
            EXPORTING
              iv_image_xstring   = iv_image_xstring
              iv_col             = lines( lt_field_catalog ) + 1
              io_excel           = lo_excel
          ).
        ENDIF.

        ""freeze column headers when scrolling
        lo_worksheet->freeze_panes( ip_num_rows = 1 ).

        "" Create output
        CREATE OBJECT lo_writer TYPE zcl_excel_writer_2007.
        ev_excel = lo_writer->write_file( lo_excel ).


      CATCH zcx_excel INTO lo_zcx_excel.    "" Exceptions for ABAP2XLSX
        ev_error_text = lo_zcx_excel->error.
        RETURN.
    ENDTRY.


    do_drm_decode(
      CHANGING
        cv_excel = ev_excel
    ).

  ENDMETHOD.


  METHOD convert_excel_to_abap.
* http://www.abap2xlsx.org
    DATA: lo_excel                    TYPE REF TO zcl_excel,
          lo_reader                   TYPE REF TO zif_excel_reader,
          lo_worksheet                TYPE REF TO zcl_excel_worksheet,
          lv_excel                    TYPE xstring,
          lt_field                    TYPE za2xh_t_fieldcatalog,
          ls_field                    TYPE za2xh_s_fieldcatalog,
          lv_highest_column           TYPE int4,
          lv_highest_row              TYPE int4,
          lv_column                   TYPE int4,
          lv_col_str                  TYPE zexcel_cell_column_alpha,
          lv_row                      TYPE int4,
          lv_value                    TYPE zexcel_cell_value,
          lv_date                     TYPE datum,
          lv_time                     TYPE uzeit,
          lv_char_row                 TYPE string,
          lv_style_guid               TYPE zexcel_cell_style,
          ls_stylemapping             TYPE zexcel_s_stylemapping,
          lt_ddic_object              TYPE dd_x031l_table,
          ls_ddic_object              TYPE x031l,
          ls_ddic_object_ref          TYPE x031l,
          lv_ddic_object_has_currency TYPE flag,
          lv_amount_external          TYPE bapicurr-bapicurr,
          lo_root                     TYPE REF TO cx_root,
          lo_zcx_excel                TYPE REF TO zcx_excel,
          lv_conversion               TYPE string,
          lv_local_ts                 TYPE timestamp,
          lv_index_col                TYPE i,
          lv_index                    TYPE i.
    FIELD-SYMBOLS: <ls_data>     TYPE data,
                   <lv_data>     TYPE data,
                   <lv_data_ref> TYPE data.

    CLEAR: ev_error_text, et_data[].

    CHECK: iv_excel IS NOT INITIAL.
    lv_excel = iv_excel.
    do_drm_decode(
      CHANGING
        cv_excel = lv_excel
    ).


    TRY.
        IF it_field IS NOT INITIAL.
          lt_field = it_field.
        ELSE.
          get_fieldcatalog(
            EXPORTING
              it_data          = et_data
            IMPORTING
              et_field         = lt_field
          ).
        ENDIF.

        CREATE OBJECT lo_reader TYPE zcl_excel_reader_2007.
        lo_excel = lo_reader->load( lv_excel  ). ""Load data into reader
        lo_excel->set_active_sheet_index( iv_sheet_no ).
        lo_worksheet = lo_excel->get_active_worksheet( ).

        lv_highest_column = lo_worksheet->get_highest_column( ).
        lv_highest_row    = lo_worksheet->get_highest_row( ).
        lv_row = iv_begin_row.

        WHILE lv_row <= lv_highest_row.
          APPEND INITIAL LINE TO et_data ASSIGNING <ls_data>.
          lv_column = 1.

          WHILE lv_column <= lv_highest_column.
            lv_col_str = zcl_excel_common=>convert_column2alpha( lv_column ).
            lo_worksheet->get_cell(
              EXPORTING
                ip_column = lv_col_str
                ip_row    = lv_row
              IMPORTING
                ep_value  = lv_value
                ep_guid   = lv_style_guid ).

            IF lv_style_guid IS NOT INITIAL AND lv_value IS NOT INITIAL.
              "" Read style attributes
              ls_stylemapping = lo_excel->get_style_to_guid( lv_style_guid ).
              CASE ls_stylemapping-complete_style-number_format-format_code.
                WHEN zcl_excel_style_number_format=>c_format_date_ddmmyyyy
                  OR zcl_excel_style_number_format=>c_format_date_ddmmyyyydot
                  OR zcl_excel_style_number_format=>c_format_date_dmminus
                  OR zcl_excel_style_number_format=>c_format_date_dmyminus
                  OR zcl_excel_style_number_format=>c_format_date_dmyslash
                  OR zcl_excel_style_number_format=>c_format_date_myminus
                  OR zcl_excel_style_number_format=>c_format_date_std
                  OR zcl_excel_style_number_format=>c_format_date_xlsx14
                  OR zcl_excel_style_number_format=>c_format_date_xlsx15
                  OR zcl_excel_style_number_format=>c_format_date_xlsx16
                  OR zcl_excel_style_number_format=>c_format_date_xlsx17
                  OR zcl_excel_style_number_format=>c_format_date_xlsx22
                  OR zcl_excel_style_number_format=>c_format_date_xlsx45
                  OR zcl_excel_style_number_format=>c_format_date_xlsx46
                  OR zcl_excel_style_number_format=>c_format_date_xlsx47
                  OR zcl_excel_style_number_format=>c_format_date_yymmdd
                  OR zcl_excel_style_number_format=>c_format_date_yymmddminus
                  OR zcl_excel_style_number_format=>c_format_date_yymmddslash
                  OR zcl_excel_style_number_format=>c_format_date_yyyymmdd
                  OR zcl_excel_style_number_format=>c_format_date_yyyymmddminus
                  OR zcl_excel_style_number_format=>c_format_date_yyyymmddslash.
                  "" Convert excel date to ABAP date
                  lv_date = zcl_excel_common=>excel_string_to_date( lv_value ).
                  lv_value = lv_date.
                WHEN zcl_excel_style_number_format=>c_format_date_time1
                  OR zcl_excel_style_number_format=>c_format_date_time2
                  OR zcl_excel_style_number_format=>c_format_date_time3
                  OR zcl_excel_style_number_format=>c_format_date_time4
                  OR zcl_excel_style_number_format=>c_format_date_time5
                  OR zcl_excel_style_number_format=>c_format_date_time6
                  OR zcl_excel_style_number_format=>c_format_date_time7
                  OR zcl_excel_style_number_format=>c_format_date_time8
                  OR 'h:mm:ss;@'.
                  "" Convert excel time to ABAP time
                  lv_time = zcl_excel_common=>excel_string_to_time( lv_value ).
                  lv_value = lv_time.
              ENDCASE.
            ENDIF.

            CONDENSE lv_value.
            IF lv_value IS NOT INITIAL.
*              ASSIGN COMPONENT lv_column OF STRUCTURE <ls_data> TO <lv_data>.
              READ TABLE lt_field INTO ls_field INDEX lv_column.
              IF sy-subrc EQ 0.
                ASSIGN COMPONENT ls_field-fieldname OF STRUCTURE <ls_data> TO <lv_data>.
                IF sy-subrc EQ 0.
                  <lv_data> = lv_value.
                ENDIF.
              ENDIF.
            ENDIF.
            lv_column = lv_column + 1.
          ENDWHILE.

          "" delete empty line
          IF <ls_data> IS INITIAL.
            DELETE et_data INDEX lines( et_data ).
          ENDIF.
          lv_row = lv_row + 1.
        ENDWHILE.


        CHECK: et_data IS NOT INITIAL.

        "" conversion exit.
        LOOP AT lt_field INTO ls_field.
          ASSIGN COMPONENT ls_field-fieldname OF STRUCTURE <ls_data> TO <lv_data>.
          DESCRIBE FIELD <lv_data> EDIT MASK lv_conversion.
          IF lv_conversion EQ '==TSTLC'.
            LOOP AT et_data ASSIGNING <ls_data>.
              lv_index = sy-tabix + 1.
              ASSIGN COMPONENT ls_field-fieldname OF STRUCTURE <ls_data> TO <lv_data>.
              IF <lv_data> IS NOT INITIAL.
                PERFORM convert_to_utc_time IN PROGRAM saplsdc_cnv USING <lv_data> CHANGING <lv_data>.
              ENDIF.
            ENDLOOP.
          ELSEIF lv_conversion EQ '==ALPHA'.
            LOOP AT et_data ASSIGNING <ls_data>.
              lv_index = sy-tabix + 1.
              ASSIGN COMPONENT ls_field-fieldname OF STRUCTURE <ls_data> TO <lv_data>.
              CALL FUNCTION 'CONVERSION_EXIT_ALPHA_INPUT'
                EXPORTING
                  input  = <lv_data>
                IMPORTING
                  output = <lv_data>.
            ENDLOOP.
          ENDIF.
        ENDLOOP.

        lt_ddic_object = get_ddic_object( et_data ).

        "" currency
        LOOP AT lt_ddic_object INTO ls_ddic_object WHERE reffield IS NOT INITIAL.
          READ TABLE lt_ddic_object INTO ls_ddic_object_ref WITH KEY fieldname = ls_ddic_object-reffield dtyp = 'CUKY'.
          CHECK: sy-subrc EQ 0.
          LOOP AT et_data ASSIGNING <ls_data>.
            lv_index = sy-tabix + 1.
            ASSIGN COMPONENT ls_ddic_object-fieldname OF STRUCTURE <ls_data> TO <lv_data>.
            IF <lv_data> IS NOT INITIAL.
              ASSIGN COMPONENT ls_ddic_object_ref-fieldname OF STRUCTURE <ls_data> TO <lv_data_ref>.
              IF <lv_data_ref> IS NOT INITIAL AND
                 <lv_data_ref> <> 'USD' AND
                 <lv_data_ref> <> 'EUR'.

                lv_amount_external = <lv_data>.
                CALL FUNCTION 'BAPI_CURRENCY_CONV_TO_INTERNAL'
                  EXPORTING
                    currency             = CONV tcurc-waers( <lv_data_ref> )
                    amount_external      = lv_amount_external
                    max_number_of_digits = 23
                  IMPORTING
                    amount_internal      = <lv_data>.
              ENDIF.
            ENDIF.
          ENDLOOP.
        ENDLOOP.


      CATCH cx_root INTO lo_root.
        ev_error_text = lo_root->get_text( ).
        IF lv_row IS NOT INITIAL.
          lv_char_row = lv_row.
          CONDENSE lv_char_row NO-GAPS.
          ev_error_text = ev_error_text && '(Col:' && lv_col_str && ',Row:' && lv_char_row && ')'.
        ENDIF.
    ENDTRY.



  ENDMETHOD.


  METHOD convert_json_to_excel.
* http://www.abap2xlsx.org
    DATA: ls_field    TYPE za2xh_s_fieldcatalog,
          lt_comp     TYPE abap_component_tab,
          ls_comp     TYPE abap_componentdescr,
          lo_tab_type TYPE REF TO cl_abap_tabledescr,
          lr_data     TYPE REF TO data.
    FIELD-SYMBOLS: <lt_data> TYPE table.

    "" json to table
    LOOP AT it_field INTO ls_field.
      ls_comp-name = ls_field-fieldname.
      ls_comp-type = cl_abap_elemdescr=>get_string( ).
      APPEND ls_comp TO lt_comp.
    ENDLOOP.
    lo_tab_type = cl_abap_tabledescr=>create( cl_abap_structdescr=>create( lt_comp ) ).
    CREATE DATA lr_data TYPE HANDLE lo_tab_type.
    ASSIGN lr_data->* TO <lt_data>.

    /ui2/cl_json=>deserialize(
      EXPORTING
        json             = iv_data_json
      CHANGING
        data             = <lt_data>
    ).

    "" table to excel
    convert_abap_to_excel(
      EXPORTING
        it_data                 = <lt_data>
        it_ddic_object          = it_ddic_object
        it_field                = it_field
        iv_sheet_title          = iv_sheet_title
        iv_image_xstring        = iv_image_xstring
        iv_add_fixedvalue_sheet = iv_add_fixedvalue_sheet
        iv_auto_column_width    = iv_auto_column_width
        iv_default_descr        = iv_default_descr
      IMPORTING
        ev_excel                = ev_excel
        ev_error_text           = ev_error_text
    ).
  ENDMETHOD.


  METHOD do_drm_decode.
* if you need to DRM decode. write code here.
  ENDMETHOD.


  METHOD do_drm_encode.
* if you need to DRM encode. write code here.
  ENDMETHOD.


  METHOD excel_download.
* http://www.abap2xlsx.org
    convert_abap_to_excel(
      EXPORTING
        it_data                 = it_data
        it_field                = it_field
        iv_sheet_title          = iv_sheet_title
        iv_image_xstring        = iv_image_xstring
        iv_add_fixedvalue_sheet = iv_add_fixedvalue_sheet
        iv_auto_column_width    = iv_auto_column_width
        iv_default_descr        = iv_default_descr
      IMPORTING
        ev_excel                = ev_excel
        ev_error_text           = ev_error_text
    ).

    IF ev_error_text IS NOT INITIAL.
      zcl_abap2xlsx_helper=>message( iv_error_text = ev_error_text ).
      RETURN.
    ENDIF.

    start_download(
      EXPORTING
        iv_excel    = ev_excel
        iv_filename = iv_filename
    ).

  ENDMETHOD.


  METHOD excel_email.
* http://www.abap2xlsx.org
    DATA: lt_receiver   TYPE TABLE OF string,
          lo_event_data TYPE REF TO if_fpm_parameter.

    IF it_receiver IS NOT INITIAL.
      lt_receiver = it_receiver.
    ELSE.
      lt_receiver = zcl_za2xh_email_popup=>get_default_receiver( ).
    ENDIF.

    lo_event_data = NEW cl_fpm_parameter( ).

    lo_event_data->set_value(
      EXPORTING
        iv_key   = 'IT_RECEIVER'
        iv_value = lt_receiver
    ).

    lo_event_data->set_value(
      EXPORTING
        iv_key   = 'IT_DATA'
        iv_value = it_data
    ).

    lo_event_data->set_value(
      EXPORTING
        iv_key   = 'IT_FIELD'
        iv_value = it_field
    ).

    lo_event_data->set_value(
      EXPORTING
        iv_key   = 'IV_SUBJECT'
        iv_value = CONV string( iv_subject )
    ).

    lo_event_data->set_value(
      EXPORTING
        iv_key   = 'IV_SENDER'
        iv_value = CONV string( iv_sender )
    ).

    lo_event_data->set_value(
      EXPORTING
        iv_key   = 'IV_FILENAME'
        iv_value = CONV string( iv_filename )
    ).

    lo_event_data->set_value(
      EXPORTING
        iv_key   = 'IV_SHEET_TITLE'
        iv_value = CONV string( iv_sheet_title )
    ).

    lo_event_data->set_value(
      EXPORTING
        iv_key   = 'IV_IMAGE_XSTRING'
        iv_value = iv_image_xstring
    ).

    lo_event_data->set_value(
      EXPORTING
        iv_key   = 'IV_ADD_FIXEDVALUE_SHEET'
        iv_value = iv_add_fixedvalue_sheet
    ).

    lo_event_data->set_value(
      EXPORTING
        iv_key   = 'IV_AUTO_COLUMN_WIDTH'
        iv_value = iv_auto_column_width
    ).

    lo_event_data->set_value(
      EXPORTING
        iv_key   = 'IV_DEFAULT_DESCR'
        iv_value = iv_default_descr
    ).


    IF wdr_task=>application IS NOT INITIAL.
      "" WD or FPM
      zcl_za2xh_email_popup=>open_popup( io_event_data = lo_event_data ).
    ELSE.
      "" GUI
      CALL FUNCTION 'ZA2XH_EMAIL_POPUP_GUI'
        EXPORTING
          io_event_data = lo_event_data.
    ENDIF.


    IF 1 EQ 2.
      "" ok click on popup
      NEW zcl_za2xh_email_popup( )->on_ok( ).
    ENDIF.

  ENDMETHOD.


  METHOD excel_upload.
* http://www.abap2xlsx.org
    DATA: lv_excel TYPE xstring.
    FIELD-SYMBOLS: <lv_excel> TYPE xstring.


    IF iv_excel IS NOT INITIAL.
      ASSIGN iv_excel TO <lv_excel>.
    ELSE.
      start_upload(
        IMPORTING
          ev_excel = lv_excel
      ).
      ASSIGN lv_excel TO <lv_excel>.
    ENDIF.

    convert_excel_to_abap(
      EXPORTING
        iv_excel      = <lv_excel>
        it_field      = it_field
        iv_begin_row  = iv_begin_row
        iv_sheet_no   = iv_sheet_no
      IMPORTING
        et_data       = et_data
        ev_error_text = ev_error_text
    ).

    IF ev_error_text IS NOT INITIAL.
      zcl_abap2xlsx_helper=>message( iv_error_text = ev_error_text ).
    ENDIF.

  ENDMETHOD.


  METHOD get_ddic_object.
    DATA: lo_type_desc   TYPE REF TO cl_abap_typedescr,
          lo_table_desc  TYPE REF TO cl_abap_tabledescr,
          lo_struct_desc TYPE REF TO cl_abap_structdescr.

    lo_type_desc = cl_abap_typedescr=>describe_by_data( i_data ).
    CASE lo_type_desc->kind.
      WHEN cl_abap_typedescr=>kind_table.
        lo_table_desc ?= lo_type_desc.
        lo_type_desc = lo_table_desc->get_table_line_type( ).
        IF lo_type_desc->kind EQ cl_abap_typedescr=>kind_struct.
          lo_struct_desc ?= lo_type_desc.
        ENDIF.
      WHEN cl_abap_typedescr=>kind_struct.
        lo_struct_desc ?= lo_type_desc.
    ENDCASE.

    IF lo_struct_desc IS NOT INITIAL.
      lo_struct_desc->get_ddic_object(
        RECEIVING
          p_object     = rt_ddic_object
        EXCEPTIONS
          not_found    = 1        "" Type could not be found
          no_ddic_type = 2        "" Typ is not a dictionary type
          OTHERS       = 3
      ).
    ENDIF.

  ENDMETHOD.


  METHOD get_fieldcatalog.
* http://www.abap2xlsx.org
    DATA: lt_fc    TYPE zexcel_t_fieldcatalog,
          ls_fc    TYPE zexcel_s_fieldcatalog,
          ls_field TYPE za2xh_s_fieldcatalog.

    lt_fc = zcl_excel_common=>get_fieldcatalog( ip_table = it_data ).
    DELETE lt_fc WHERE dynpfld NE abap_true.

    LOOP AT lt_fc INTO ls_fc.
      ls_field-fieldname = ls_fc-fieldname.
      CASE iv_default_descr.
        WHEN 'L'.
          ls_field-label_text = ls_fc-scrtext_l.
        WHEN 'M'.
          ls_field-label_text = ls_fc-scrtext_m.
        WHEN 'S'.
          ls_field-label_text = ls_fc-scrtext_s.
        WHEN OTHERS.
          CLEAR: ls_field-label_text.
      ENDCASE.
      APPEND ls_field TO et_field.
    ENDLOOP.
  ENDMETHOD.


  METHOD get_xstring_from_smw0.
    DATA: lo_drawing TYPE REF TO zcl_excel_drawing.

    CREATE OBJECT lo_drawing.
    lo_drawing->set_media_www(
      EXPORTING
        ip_key    = VALUE #( relid = 'MI' objid = iv_smw0 )
        ip_width  = 0
        ip_height = 0
    ).
    rv_xstring = lo_drawing->get_media( ).
  ENDMETHOD.


  METHOD start_download.
    DATA: lv_filename_string   TYPE string,
          lv_filename_path     TYPE string,
          lv_filename_fullpath TYPE string,
          lv_bin_filesize      TYPE i,
          lt_temptable         TYPE w3mimetabtype.


    IF iv_filename IS NOT INITIAL.
      lv_filename_string = iv_filename.
    ELSE.
      lv_filename_string = zcl_abap2xlsx_helper=>default_excel_filename( ).
    ENDIF.

    IF wdr_task=>application IS NOT INITIAL.
      "" WD or FPM
      CALL METHOD cl_wd_runtime_services=>attach_file_to_response
        EXPORTING
          i_filename  = lv_filename_string
          i_content   = iv_excel
          i_mime_type = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'.
    ELSE.
      "" GUI
      CALL FUNCTION 'SCMS_XSTRING_TO_BINARY'
        EXPORTING
          buffer        = iv_excel
        IMPORTING
          output_length = lv_bin_filesize
        TABLES
          binary_tab    = lt_temptable.
      cl_gui_frontend_services=>file_save_dialog(
        EXPORTING
          default_file_name         = lv_filename_string "" DEFAULT FILE NAME
          file_filter               = '*.xlsx'       "" file type filter table
        CHANGING
          filename                  = lv_filename_string          "" file name to save
          path                      = lv_filename_path              "" path to file
          fullpath                  = lv_filename_fullpath          "" path + file name
        EXCEPTIONS
          OTHERS                    = 5
      ).
      IF sy-subrc <> 0.
        MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno
          WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
      ENDIF.
      IF lv_filename_fullpath IS NOT INITIAL.
        cl_gui_frontend_services=>gui_download(
           EXPORTING
             bin_filesize = lv_bin_filesize
             filename     = lv_filename_fullpath
             filetype     = 'BIN'
           CHANGING
             data_tab     = lt_temptable
           EXCEPTIONS
             file_write_error          = 1
             no_batch                  = 2
             gui_refuse_filetransfer   = 3
             invalid_type              = 4
             no_authority              = 5
             unknown_error             = 6
             header_not_allowed        = 7
             separator_not_allowed     = 8
             filesize_not_allowed      = 9
             header_too_long           = 10
             dp_error_create           = 11
             dp_error_send             = 12
             dp_error_write            = 13
             unknown_dp_error          = 14
             access_denied             = 15
             dp_out_of_memory          = 16
             disk_full                 = 17
             dp_timeout                = 18
             file_not_found            = 19
             dataprovider_exception    = 20
             control_flush_error       = 21
             not_supported_by_gui      = 22
             error_no_gui              = 23
             OTHERS                    = 24
        ).
        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.
    ENDIF.

  ENDMETHOD.


  METHOD start_upload.
    DATA: lt_file_table	TYPE filetable,
          ls_file_table TYPE file_table,
          lv_rc	        TYPE i,
          lv_filename   TYPE string,
          lv_filelength TYPE i,
          lt_temptable  TYPE w3mimetabtype.

    IF wdr_task=>application IS NOT INITIAL.
      "" WD or FPM
      RETURN.
    ELSE.
      "" GUI
      cl_gui_frontend_services=>file_open_dialog(
        EXPORTING
*         window_title            = window_title      "" Title Of File Open Dialog
          default_extension       = 'xlsx' "" Default Extension
*         default_filename        = default_filename  "" Default File Name
          file_filter             = 'excel (*.xlsx)|*.xlsx|'       "" File Extension Filter String
*         with_encoding           = with_encoding     "" File Encoding
*         initial_directory       = initial_directory "" Initial Directory
          multiselection          = abap_false    "" Multiple selections poss.
        CHANGING
          file_table              = lt_file_table        "" Table Holding Selected Files
          rc                      = lv_rc                "" Return Code, Number of Files or -1 If Error Occurred
*         user_action             = user_action       "" User Action (See Class Constants ACTION_OK, ACTION_CANCEL)
*         file_encoding           = file_encoding
        EXCEPTIONS
          file_open_dialog_failed = 1                 "" ""Open File"" dialog failed
          cntl_error              = 2                 "" Control error
          error_no_gui            = 3                 "" No GUI available
          not_supported_by_gui    = 4                 "" GUI does not support this
          OTHERS                  = 5
      ).
      IF sy-subrc <> 0.
        MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno
          WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
      ENDIF.

      READ TABLE lt_file_table INTO ls_file_table INDEX 1.
      CHECK: sy-subrc EQ 0.
      lv_filename = ls_file_table-filename.

      cl_gui_frontend_services=>gui_upload(
        EXPORTING
          filename                = lv_filename              "" Name of file
          filetype                = 'BIN'              "" File Type (ASCII, Binary)
*         has_field_separator     = space              "" Columns Separated by Tabs in Case of ASCII Upload
*         header_length           = 0                  "" Length of Header for Binary Data
*         read_by_line            = 'X'                "" File Written Line-By-Line to the Internal Table
*         dat_mode                = space              "" Numeric and date fields are in DAT format in WS_DOWNLOAD
*         codepage                = codepage           "" Character Representation for Output
*         ignore_cerr             = abap_true          "" Ignore character set conversion errors?
*         replacement             = '#'                "" Replacement Character for Non-Convertible Characters
*         virus_scan_profile      = virus_scan_profile "" Virus Scan Profile
        IMPORTING
          filelength              = lv_filelength         "" File Length
*         header                  = header             "" File Header in Case of Binary Upload
        CHANGING
          data_tab                = lt_temptable           "" Transfer table for file contents
*         isscanperformed         = space              "" File already scanned
        EXCEPTIONS
          file_open_error         = 1                  "" File does not exist and cannot be opened
          file_read_error         = 2                  "" Error when reading file
          no_batch                = 3                  "" Cannot execute front-end function in background
          gui_refuse_filetransfer = 4                  "" Incorrect front end or error on front end
          invalid_type            = 5                  "" Incorrect parameter FILETYPE
          no_authority            = 6                  "" No upload authorization
          unknown_error           = 7                  "" Unknown error
          bad_data_format         = 8                  "" Cannot Interpret Data in File
          header_not_allowed      = 9                  "" Invalid header
          separator_not_allowed   = 10                 "" Invalid separator
          header_too_long         = 11                 "" Header information currently restricted to 1023 bytes
          unknown_dp_error        = 12                 "" Error when calling data provider
          access_denied           = 13                 "" Access to file denied.
          dp_out_of_memory        = 14                 "" Not enough memory in data provider
          disk_full               = 15                 "" Storage medium is full.
          dp_timeout              = 16                 "" Data provider timeout
          not_supported_by_gui    = 17                 "" GUI does not support this
          error_no_gui            = 18                 "" GUI not available
          OTHERS                  = 19
      ).
      IF sy-subrc <> 0.
        MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno
          WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
      ENDIF.

      CALL FUNCTION 'SCMS_BINARY_TO_XSTRING'
        EXPORTING
          input_length = lv_filelength
*         first_line   = 0
*         last_line    = 0
        IMPORTING
          buffer       = ev_excel
        TABLES
          binary_tab   = lt_temptable
        EXCEPTIONS
          failed       = 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.
      ENDIF.
    ENDIF.
  ENDMETHOD.
ENDCLASS.
",10681,False,2022.1649513606653,median
"# /* **************************************************************************
#  *                                                                          *
#  *     (C) Copyright Paul Mensonides 2002.  Permission to copy, use,        *
#  *     modify, sell, and distribute this software is granted provided       *
#  *     this copyright notice appears in all copies.  This software is       *
#  *     provided ""as is"" without express or implied warranty, and with       *
#  *     no claim at to its suitability for any purpose.                      *
#  *                                                                          *
#  ************************************************************************** */
#
# /* See http://www.boost.org for most recent version. */
#
# if BOOST_PP_ITERATION_FINISH_2 <= 256 && BOOST_PP_ITERATION_START_2 >= 256
#    define BOOST_PP_ITERATION_2 256
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 255 && BOOST_PP_ITERATION_START_2 >= 255
#    define BOOST_PP_ITERATION_2 255
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 254 && BOOST_PP_ITERATION_START_2 >= 254
#    define BOOST_PP_ITERATION_2 254
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 253 && BOOST_PP_ITERATION_START_2 >= 253
#    define BOOST_PP_ITERATION_2 253
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 252 && BOOST_PP_ITERATION_START_2 >= 252
#    define BOOST_PP_ITERATION_2 252
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 251 && BOOST_PP_ITERATION_START_2 >= 251
#    define BOOST_PP_ITERATION_2 251
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 250 && BOOST_PP_ITERATION_START_2 >= 250
#    define BOOST_PP_ITERATION_2 250
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 249 && BOOST_PP_ITERATION_START_2 >= 249
#    define BOOST_PP_ITERATION_2 249
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 248 && BOOST_PP_ITERATION_START_2 >= 248
#    define BOOST_PP_ITERATION_2 248
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 247 && BOOST_PP_ITERATION_START_2 >= 247
#    define BOOST_PP_ITERATION_2 247
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 246 && BOOST_PP_ITERATION_START_2 >= 246
#    define BOOST_PP_ITERATION_2 246
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 245 && BOOST_PP_ITERATION_START_2 >= 245
#    define BOOST_PP_ITERATION_2 245
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 244 && BOOST_PP_ITERATION_START_2 >= 244
#    define BOOST_PP_ITERATION_2 244
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 243 && BOOST_PP_ITERATION_START_2 >= 243
#    define BOOST_PP_ITERATION_2 243
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 242 && BOOST_PP_ITERATION_START_2 >= 242
#    define BOOST_PP_ITERATION_2 242
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 241 && BOOST_PP_ITERATION_START_2 >= 241
#    define BOOST_PP_ITERATION_2 241
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 240 && BOOST_PP_ITERATION_START_2 >= 240
#    define BOOST_PP_ITERATION_2 240
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 239 && BOOST_PP_ITERATION_START_2 >= 239
#    define BOOST_PP_ITERATION_2 239
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 238 && BOOST_PP_ITERATION_START_2 >= 238
#    define BOOST_PP_ITERATION_2 238
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 237 && BOOST_PP_ITERATION_START_2 >= 237
#    define BOOST_PP_ITERATION_2 237
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 236 && BOOST_PP_ITERATION_START_2 >= 236
#    define BOOST_PP_ITERATION_2 236
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 235 && BOOST_PP_ITERATION_START_2 >= 235
#    define BOOST_PP_ITERATION_2 235
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 234 && BOOST_PP_ITERATION_START_2 >= 234
#    define BOOST_PP_ITERATION_2 234
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 233 && BOOST_PP_ITERATION_START_2 >= 233
#    define BOOST_PP_ITERATION_2 233
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 232 && BOOST_PP_ITERATION_START_2 >= 232
#    define BOOST_PP_ITERATION_2 232
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 231 && BOOST_PP_ITERATION_START_2 >= 231
#    define BOOST_PP_ITERATION_2 231
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 230 && BOOST_PP_ITERATION_START_2 >= 230
#    define BOOST_PP_ITERATION_2 230
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 229 && BOOST_PP_ITERATION_START_2 >= 229
#    define BOOST_PP_ITERATION_2 229
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 228 && BOOST_PP_ITERATION_START_2 >= 228
#    define BOOST_PP_ITERATION_2 228
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 227 && BOOST_PP_ITERATION_START_2 >= 227
#    define BOOST_PP_ITERATION_2 227
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 226 && BOOST_PP_ITERATION_START_2 >= 226
#    define BOOST_PP_ITERATION_2 226
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 225 && BOOST_PP_ITERATION_START_2 >= 225
#    define BOOST_PP_ITERATION_2 225
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 224 && BOOST_PP_ITERATION_START_2 >= 224
#    define BOOST_PP_ITERATION_2 224
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 223 && BOOST_PP_ITERATION_START_2 >= 223
#    define BOOST_PP_ITERATION_2 223
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 222 && BOOST_PP_ITERATION_START_2 >= 222
#    define BOOST_PP_ITERATION_2 222
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 221 && BOOST_PP_ITERATION_START_2 >= 221
#    define BOOST_PP_ITERATION_2 221
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 220 && BOOST_PP_ITERATION_START_2 >= 220
#    define BOOST_PP_ITERATION_2 220
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 219 && BOOST_PP_ITERATION_START_2 >= 219
#    define BOOST_PP_ITERATION_2 219
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 218 && BOOST_PP_ITERATION_START_2 >= 218
#    define BOOST_PP_ITERATION_2 218
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 217 && BOOST_PP_ITERATION_START_2 >= 217
#    define BOOST_PP_ITERATION_2 217
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 216 && BOOST_PP_ITERATION_START_2 >= 216
#    define BOOST_PP_ITERATION_2 216
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 215 && BOOST_PP_ITERATION_START_2 >= 215
#    define BOOST_PP_ITERATION_2 215
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 214 && BOOST_PP_ITERATION_START_2 >= 214
#    define BOOST_PP_ITERATION_2 214
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 213 && BOOST_PP_ITERATION_START_2 >= 213
#    define BOOST_PP_ITERATION_2 213
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 212 && BOOST_PP_ITERATION_START_2 >= 212
#    define BOOST_PP_ITERATION_2 212
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 211 && BOOST_PP_ITERATION_START_2 >= 211
#    define BOOST_PP_ITERATION_2 211
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 210 && BOOST_PP_ITERATION_START_2 >= 210
#    define BOOST_PP_ITERATION_2 210
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 209 && BOOST_PP_ITERATION_START_2 >= 209
#    define BOOST_PP_ITERATION_2 209
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 208 && BOOST_PP_ITERATION_START_2 >= 208
#    define BOOST_PP_ITERATION_2 208
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 207 && BOOST_PP_ITERATION_START_2 >= 207
#    define BOOST_PP_ITERATION_2 207
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 206 && BOOST_PP_ITERATION_START_2 >= 206
#    define BOOST_PP_ITERATION_2 206
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 205 && BOOST_PP_ITERATION_START_2 >= 205
#    define BOOST_PP_ITERATION_2 205
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 204 && BOOST_PP_ITERATION_START_2 >= 204
#    define BOOST_PP_ITERATION_2 204
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 203 && BOOST_PP_ITERATION_START_2 >= 203
#    define BOOST_PP_ITERATION_2 203
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 202 && BOOST_PP_ITERATION_START_2 >= 202
#    define BOOST_PP_ITERATION_2 202
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 201 && BOOST_PP_ITERATION_START_2 >= 201
#    define BOOST_PP_ITERATION_2 201
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 200 && BOOST_PP_ITERATION_START_2 >= 200
#    define BOOST_PP_ITERATION_2 200
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 199 && BOOST_PP_ITERATION_START_2 >= 199
#    define BOOST_PP_ITERATION_2 199
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 198 && BOOST_PP_ITERATION_START_2 >= 198
#    define BOOST_PP_ITERATION_2 198
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 197 && BOOST_PP_ITERATION_START_2 >= 197
#    define BOOST_PP_ITERATION_2 197
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 196 && BOOST_PP_ITERATION_START_2 >= 196
#    define BOOST_PP_ITERATION_2 196
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 195 && BOOST_PP_ITERATION_START_2 >= 195
#    define BOOST_PP_ITERATION_2 195
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 194 && BOOST_PP_ITERATION_START_2 >= 194
#    define BOOST_PP_ITERATION_2 194
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 193 && BOOST_PP_ITERATION_START_2 >= 193
#    define BOOST_PP_ITERATION_2 193
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 192 && BOOST_PP_ITERATION_START_2 >= 192
#    define BOOST_PP_ITERATION_2 192
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 191 && BOOST_PP_ITERATION_START_2 >= 191
#    define BOOST_PP_ITERATION_2 191
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 190 && BOOST_PP_ITERATION_START_2 >= 190
#    define BOOST_PP_ITERATION_2 190
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 189 && BOOST_PP_ITERATION_START_2 >= 189
#    define BOOST_PP_ITERATION_2 189
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 188 && BOOST_PP_ITERATION_START_2 >= 188
#    define BOOST_PP_ITERATION_2 188
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 187 && BOOST_PP_ITERATION_START_2 >= 187
#    define BOOST_PP_ITERATION_2 187
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 186 && BOOST_PP_ITERATION_START_2 >= 186
#    define BOOST_PP_ITERATION_2 186
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 185 && BOOST_PP_ITERATION_START_2 >= 185
#    define BOOST_PP_ITERATION_2 185
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 184 && BOOST_PP_ITERATION_START_2 >= 184
#    define BOOST_PP_ITERATION_2 184
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 183 && BOOST_PP_ITERATION_START_2 >= 183
#    define BOOST_PP_ITERATION_2 183
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 182 && BOOST_PP_ITERATION_START_2 >= 182
#    define BOOST_PP_ITERATION_2 182
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 181 && BOOST_PP_ITERATION_START_2 >= 181
#    define BOOST_PP_ITERATION_2 181
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 180 && BOOST_PP_ITERATION_START_2 >= 180
#    define BOOST_PP_ITERATION_2 180
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 179 && BOOST_PP_ITERATION_START_2 >= 179
#    define BOOST_PP_ITERATION_2 179
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 178 && BOOST_PP_ITERATION_START_2 >= 178
#    define BOOST_PP_ITERATION_2 178
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 177 && BOOST_PP_ITERATION_START_2 >= 177
#    define BOOST_PP_ITERATION_2 177
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 176 && BOOST_PP_ITERATION_START_2 >= 176
#    define BOOST_PP_ITERATION_2 176
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 175 && BOOST_PP_ITERATION_START_2 >= 175
#    define BOOST_PP_ITERATION_2 175
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 174 && BOOST_PP_ITERATION_START_2 >= 174
#    define BOOST_PP_ITERATION_2 174
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 173 && BOOST_PP_ITERATION_START_2 >= 173
#    define BOOST_PP_ITERATION_2 173
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 172 && BOOST_PP_ITERATION_START_2 >= 172
#    define BOOST_PP_ITERATION_2 172
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 171 && BOOST_PP_ITERATION_START_2 >= 171
#    define BOOST_PP_ITERATION_2 171
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 170 && BOOST_PP_ITERATION_START_2 >= 170
#    define BOOST_PP_ITERATION_2 170
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 169 && BOOST_PP_ITERATION_START_2 >= 169
#    define BOOST_PP_ITERATION_2 169
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 168 && BOOST_PP_ITERATION_START_2 >= 168
#    define BOOST_PP_ITERATION_2 168
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 167 && BOOST_PP_ITERATION_START_2 >= 167
#    define BOOST_PP_ITERATION_2 167
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 166 && BOOST_PP_ITERATION_START_2 >= 166
#    define BOOST_PP_ITERATION_2 166
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 165 && BOOST_PP_ITERATION_START_2 >= 165
#    define BOOST_PP_ITERATION_2 165
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 164 && BOOST_PP_ITERATION_START_2 >= 164
#    define BOOST_PP_ITERATION_2 164
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 163 && BOOST_PP_ITERATION_START_2 >= 163
#    define BOOST_PP_ITERATION_2 163
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 162 && BOOST_PP_ITERATION_START_2 >= 162
#    define BOOST_PP_ITERATION_2 162
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 161 && BOOST_PP_ITERATION_START_2 >= 161
#    define BOOST_PP_ITERATION_2 161
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 160 && BOOST_PP_ITERATION_START_2 >= 160
#    define BOOST_PP_ITERATION_2 160
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 159 && BOOST_PP_ITERATION_START_2 >= 159
#    define BOOST_PP_ITERATION_2 159
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 158 && BOOST_PP_ITERATION_START_2 >= 158
#    define BOOST_PP_ITERATION_2 158
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 157 && BOOST_PP_ITERATION_START_2 >= 157
#    define BOOST_PP_ITERATION_2 157
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 156 && BOOST_PP_ITERATION_START_2 >= 156
#    define BOOST_PP_ITERATION_2 156
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 155 && BOOST_PP_ITERATION_START_2 >= 155
#    define BOOST_PP_ITERATION_2 155
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 154 && BOOST_PP_ITERATION_START_2 >= 154
#    define BOOST_PP_ITERATION_2 154
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 153 && BOOST_PP_ITERATION_START_2 >= 153
#    define BOOST_PP_ITERATION_2 153
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 152 && BOOST_PP_ITERATION_START_2 >= 152
#    define BOOST_PP_ITERATION_2 152
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 151 && BOOST_PP_ITERATION_START_2 >= 151
#    define BOOST_PP_ITERATION_2 151
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 150 && BOOST_PP_ITERATION_START_2 >= 150
#    define BOOST_PP_ITERATION_2 150
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 149 && BOOST_PP_ITERATION_START_2 >= 149
#    define BOOST_PP_ITERATION_2 149
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 148 && BOOST_PP_ITERATION_START_2 >= 148
#    define BOOST_PP_ITERATION_2 148
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 147 && BOOST_PP_ITERATION_START_2 >= 147
#    define BOOST_PP_ITERATION_2 147
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 146 && BOOST_PP_ITERATION_START_2 >= 146
#    define BOOST_PP_ITERATION_2 146
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 145 && BOOST_PP_ITERATION_START_2 >= 145
#    define BOOST_PP_ITERATION_2 145
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 144 && BOOST_PP_ITERATION_START_2 >= 144
#    define BOOST_PP_ITERATION_2 144
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 143 && BOOST_PP_ITERATION_START_2 >= 143
#    define BOOST_PP_ITERATION_2 143
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 142 && BOOST_PP_ITERATION_START_2 >= 142
#    define BOOST_PP_ITERATION_2 142
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 141 && BOOST_PP_ITERATION_START_2 >= 141
#    define BOOST_PP_ITERATION_2 141
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 140 && BOOST_PP_ITERATION_START_2 >= 140
#    define BOOST_PP_ITERATION_2 140
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 139 && BOOST_PP_ITERATION_START_2 >= 139
#    define BOOST_PP_ITERATION_2 139
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 138 && BOOST_PP_ITERATION_START_2 >= 138
#    define BOOST_PP_ITERATION_2 138
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 137 && BOOST_PP_ITERATION_START_2 >= 137
#    define BOOST_PP_ITERATION_2 137
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 136 && BOOST_PP_ITERATION_START_2 >= 136
#    define BOOST_PP_ITERATION_2 136
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 135 && BOOST_PP_ITERATION_START_2 >= 135
#    define BOOST_PP_ITERATION_2 135
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 134 && BOOST_PP_ITERATION_START_2 >= 134
#    define BOOST_PP_ITERATION_2 134
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 133 && BOOST_PP_ITERATION_START_2 >= 133
#    define BOOST_PP_ITERATION_2 133
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 132 && BOOST_PP_ITERATION_START_2 >= 132
#    define BOOST_PP_ITERATION_2 132
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 131 && BOOST_PP_ITERATION_START_2 >= 131
#    define BOOST_PP_ITERATION_2 131
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 130 && BOOST_PP_ITERATION_START_2 >= 130
#    define BOOST_PP_ITERATION_2 130
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 129 && BOOST_PP_ITERATION_START_2 >= 129
#    define BOOST_PP_ITERATION_2 129
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 128 && BOOST_PP_ITERATION_START_2 >= 128
#    define BOOST_PP_ITERATION_2 128
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 127 && BOOST_PP_ITERATION_START_2 >= 127
#    define BOOST_PP_ITERATION_2 127
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 126 && BOOST_PP_ITERATION_START_2 >= 126
#    define BOOST_PP_ITERATION_2 126
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 125 && BOOST_PP_ITERATION_START_2 >= 125
#    define BOOST_PP_ITERATION_2 125
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 124 && BOOST_PP_ITERATION_START_2 >= 124
#    define BOOST_PP_ITERATION_2 124
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 123 && BOOST_PP_ITERATION_START_2 >= 123
#    define BOOST_PP_ITERATION_2 123
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 122 && BOOST_PP_ITERATION_START_2 >= 122
#    define BOOST_PP_ITERATION_2 122
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 121 && BOOST_PP_ITERATION_START_2 >= 121
#    define BOOST_PP_ITERATION_2 121
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 120 && BOOST_PP_ITERATION_START_2 >= 120
#    define BOOST_PP_ITERATION_2 120
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 119 && BOOST_PP_ITERATION_START_2 >= 119
#    define BOOST_PP_ITERATION_2 119
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 118 && BOOST_PP_ITERATION_START_2 >= 118
#    define BOOST_PP_ITERATION_2 118
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 117 && BOOST_PP_ITERATION_START_2 >= 117
#    define BOOST_PP_ITERATION_2 117
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 116 && BOOST_PP_ITERATION_START_2 >= 116
#    define BOOST_PP_ITERATION_2 116
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 115 && BOOST_PP_ITERATION_START_2 >= 115
#    define BOOST_PP_ITERATION_2 115
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 114 && BOOST_PP_ITERATION_START_2 >= 114
#    define BOOST_PP_ITERATION_2 114
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 113 && BOOST_PP_ITERATION_START_2 >= 113
#    define BOOST_PP_ITERATION_2 113
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 112 && BOOST_PP_ITERATION_START_2 >= 112
#    define BOOST_PP_ITERATION_2 112
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 111 && BOOST_PP_ITERATION_START_2 >= 111
#    define BOOST_PP_ITERATION_2 111
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 110 && BOOST_PP_ITERATION_START_2 >= 110
#    define BOOST_PP_ITERATION_2 110
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 109 && BOOST_PP_ITERATION_START_2 >= 109
#    define BOOST_PP_ITERATION_2 109
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 108 && BOOST_PP_ITERATION_START_2 >= 108
#    define BOOST_PP_ITERATION_2 108
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 107 && BOOST_PP_ITERATION_START_2 >= 107
#    define BOOST_PP_ITERATION_2 107
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 106 && BOOST_PP_ITERATION_START_2 >= 106
#    define BOOST_PP_ITERATION_2 106
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 105 && BOOST_PP_ITERATION_START_2 >= 105
#    define BOOST_PP_ITERATION_2 105
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 104 && BOOST_PP_ITERATION_START_2 >= 104
#    define BOOST_PP_ITERATION_2 104
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 103 && BOOST_PP_ITERATION_START_2 >= 103
#    define BOOST_PP_ITERATION_2 103
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 102 && BOOST_PP_ITERATION_START_2 >= 102
#    define BOOST_PP_ITERATION_2 102
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 101 && BOOST_PP_ITERATION_START_2 >= 101
#    define BOOST_PP_ITERATION_2 101
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 100 && BOOST_PP_ITERATION_START_2 >= 100
#    define BOOST_PP_ITERATION_2 100
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 99 && BOOST_PP_ITERATION_START_2 >= 99
#    define BOOST_PP_ITERATION_2 99
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 98 && BOOST_PP_ITERATION_START_2 >= 98
#    define BOOST_PP_ITERATION_2 98
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 97 && BOOST_PP_ITERATION_START_2 >= 97
#    define BOOST_PP_ITERATION_2 97
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 96 && BOOST_PP_ITERATION_START_2 >= 96
#    define BOOST_PP_ITERATION_2 96
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 95 && BOOST_PP_ITERATION_START_2 >= 95
#    define BOOST_PP_ITERATION_2 95
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 94 && BOOST_PP_ITERATION_START_2 >= 94
#    define BOOST_PP_ITERATION_2 94
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 93 && BOOST_PP_ITERATION_START_2 >= 93
#    define BOOST_PP_ITERATION_2 93
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 92 && BOOST_PP_ITERATION_START_2 >= 92
#    define BOOST_PP_ITERATION_2 92
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 91 && BOOST_PP_ITERATION_START_2 >= 91
#    define BOOST_PP_ITERATION_2 91
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 90 && BOOST_PP_ITERATION_START_2 >= 90
#    define BOOST_PP_ITERATION_2 90
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 89 && BOOST_PP_ITERATION_START_2 >= 89
#    define BOOST_PP_ITERATION_2 89
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 88 && BOOST_PP_ITERATION_START_2 >= 88
#    define BOOST_PP_ITERATION_2 88
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 87 && BOOST_PP_ITERATION_START_2 >= 87
#    define BOOST_PP_ITERATION_2 87
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 86 && BOOST_PP_ITERATION_START_2 >= 86
#    define BOOST_PP_ITERATION_2 86
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 85 && BOOST_PP_ITERATION_START_2 >= 85
#    define BOOST_PP_ITERATION_2 85
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 84 && BOOST_PP_ITERATION_START_2 >= 84
#    define BOOST_PP_ITERATION_2 84
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 83 && BOOST_PP_ITERATION_START_2 >= 83
#    define BOOST_PP_ITERATION_2 83
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 82 && BOOST_PP_ITERATION_START_2 >= 82
#    define BOOST_PP_ITERATION_2 82
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 81 && BOOST_PP_ITERATION_START_2 >= 81
#    define BOOST_PP_ITERATION_2 81
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 80 && BOOST_PP_ITERATION_START_2 >= 80
#    define BOOST_PP_ITERATION_2 80
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 79 && BOOST_PP_ITERATION_START_2 >= 79
#    define BOOST_PP_ITERATION_2 79
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 78 && BOOST_PP_ITERATION_START_2 >= 78
#    define BOOST_PP_ITERATION_2 78
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 77 && BOOST_PP_ITERATION_START_2 >= 77
#    define BOOST_PP_ITERATION_2 77
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 76 && BOOST_PP_ITERATION_START_2 >= 76
#    define BOOST_PP_ITERATION_2 76
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 75 && BOOST_PP_ITERATION_START_2 >= 75
#    define BOOST_PP_ITERATION_2 75
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 74 && BOOST_PP_ITERATION_START_2 >= 74
#    define BOOST_PP_ITERATION_2 74
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 73 && BOOST_PP_ITERATION_START_2 >= 73
#    define BOOST_PP_ITERATION_2 73
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 72 && BOOST_PP_ITERATION_START_2 >= 72
#    define BOOST_PP_ITERATION_2 72
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 71 && BOOST_PP_ITERATION_START_2 >= 71
#    define BOOST_PP_ITERATION_2 71
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 70 && BOOST_PP_ITERATION_START_2 >= 70
#    define BOOST_PP_ITERATION_2 70
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 69 && BOOST_PP_ITERATION_START_2 >= 69
#    define BOOST_PP_ITERATION_2 69
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 68 && BOOST_PP_ITERATION_START_2 >= 68
#    define BOOST_PP_ITERATION_2 68
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 67 && BOOST_PP_ITERATION_START_2 >= 67
#    define BOOST_PP_ITERATION_2 67
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 66 && BOOST_PP_ITERATION_START_2 >= 66
#    define BOOST_PP_ITERATION_2 66
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 65 && BOOST_PP_ITERATION_START_2 >= 65
#    define BOOST_PP_ITERATION_2 65
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 64 && BOOST_PP_ITERATION_START_2 >= 64
#    define BOOST_PP_ITERATION_2 64
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 63 && BOOST_PP_ITERATION_START_2 >= 63
#    define BOOST_PP_ITERATION_2 63
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 62 && BOOST_PP_ITERATION_START_2 >= 62
#    define BOOST_PP_ITERATION_2 62
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 61 && BOOST_PP_ITERATION_START_2 >= 61
#    define BOOST_PP_ITERATION_2 61
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 60 && BOOST_PP_ITERATION_START_2 >= 60
#    define BOOST_PP_ITERATION_2 60
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 59 && BOOST_PP_ITERATION_START_2 >= 59
#    define BOOST_PP_ITERATION_2 59
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 58 && BOOST_PP_ITERATION_START_2 >= 58
#    define BOOST_PP_ITERATION_2 58
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 57 && BOOST_PP_ITERATION_START_2 >= 57
#    define BOOST_PP_ITERATION_2 57
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 56 && BOOST_PP_ITERATION_START_2 >= 56
#    define BOOST_PP_ITERATION_2 56
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 55 && BOOST_PP_ITERATION_START_2 >= 55
#    define BOOST_PP_ITERATION_2 55
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 54 && BOOST_PP_ITERATION_START_2 >= 54
#    define BOOST_PP_ITERATION_2 54
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 53 && BOOST_PP_ITERATION_START_2 >= 53
#    define BOOST_PP_ITERATION_2 53
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 52 && BOOST_PP_ITERATION_START_2 >= 52
#    define BOOST_PP_ITERATION_2 52
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 51 && BOOST_PP_ITERATION_START_2 >= 51
#    define BOOST_PP_ITERATION_2 51
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 50 && BOOST_PP_ITERATION_START_2 >= 50
#    define BOOST_PP_ITERATION_2 50
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 49 && BOOST_PP_ITERATION_START_2 >= 49
#    define BOOST_PP_ITERATION_2 49
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 48 && BOOST_PP_ITERATION_START_2 >= 48
#    define BOOST_PP_ITERATION_2 48
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 47 && BOOST_PP_ITERATION_START_2 >= 47
#    define BOOST_PP_ITERATION_2 47
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 46 && BOOST_PP_ITERATION_START_2 >= 46
#    define BOOST_PP_ITERATION_2 46
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 45 && BOOST_PP_ITERATION_START_2 >= 45
#    define BOOST_PP_ITERATION_2 45
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 44 && BOOST_PP_ITERATION_START_2 >= 44
#    define BOOST_PP_ITERATION_2 44
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 43 && BOOST_PP_ITERATION_START_2 >= 43
#    define BOOST_PP_ITERATION_2 43
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 42 && BOOST_PP_ITERATION_START_2 >= 42
#    define BOOST_PP_ITERATION_2 42
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 41 && BOOST_PP_ITERATION_START_2 >= 41
#    define BOOST_PP_ITERATION_2 41
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 40 && BOOST_PP_ITERATION_START_2 >= 40
#    define BOOST_PP_ITERATION_2 40
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 39 && BOOST_PP_ITERATION_START_2 >= 39
#    define BOOST_PP_ITERATION_2 39
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 38 && BOOST_PP_ITERATION_START_2 >= 38
#    define BOOST_PP_ITERATION_2 38
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 37 && BOOST_PP_ITERATION_START_2 >= 37
#    define BOOST_PP_ITERATION_2 37
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 36 && BOOST_PP_ITERATION_START_2 >= 36
#    define BOOST_PP_ITERATION_2 36
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 35 && BOOST_PP_ITERATION_START_2 >= 35
#    define BOOST_PP_ITERATION_2 35
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 34 && BOOST_PP_ITERATION_START_2 >= 34
#    define BOOST_PP_ITERATION_2 34
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 33 && BOOST_PP_ITERATION_START_2 >= 33
#    define BOOST_PP_ITERATION_2 33
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 32 && BOOST_PP_ITERATION_START_2 >= 32
#    define BOOST_PP_ITERATION_2 32
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 31 && BOOST_PP_ITERATION_START_2 >= 31
#    define BOOST_PP_ITERATION_2 31
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 30 && BOOST_PP_ITERATION_START_2 >= 30
#    define BOOST_PP_ITERATION_2 30
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 29 && BOOST_PP_ITERATION_START_2 >= 29
#    define BOOST_PP_ITERATION_2 29
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 28 && BOOST_PP_ITERATION_START_2 >= 28
#    define BOOST_PP_ITERATION_2 28
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 27 && BOOST_PP_ITERATION_START_2 >= 27
#    define BOOST_PP_ITERATION_2 27
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 26 && BOOST_PP_ITERATION_START_2 >= 26
#    define BOOST_PP_ITERATION_2 26
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 25 && BOOST_PP_ITERATION_START_2 >= 25
#    define BOOST_PP_ITERATION_2 25
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 24 && BOOST_PP_ITERATION_START_2 >= 24
#    define BOOST_PP_ITERATION_2 24
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 23 && BOOST_PP_ITERATION_START_2 >= 23
#    define BOOST_PP_ITERATION_2 23
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 22 && BOOST_PP_ITERATION_START_2 >= 22
#    define BOOST_PP_ITERATION_2 22
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 21 && BOOST_PP_ITERATION_START_2 >= 21
#    define BOOST_PP_ITERATION_2 21
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 20 && BOOST_PP_ITERATION_START_2 >= 20
#    define BOOST_PP_ITERATION_2 20
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 19 && BOOST_PP_ITERATION_START_2 >= 19
#    define BOOST_PP_ITERATION_2 19
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 18 && BOOST_PP_ITERATION_START_2 >= 18
#    define BOOST_PP_ITERATION_2 18
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 17 && BOOST_PP_ITERATION_START_2 >= 17
#    define BOOST_PP_ITERATION_2 17
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 16 && BOOST_PP_ITERATION_START_2 >= 16
#    define BOOST_PP_ITERATION_2 16
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 15 && BOOST_PP_ITERATION_START_2 >= 15
#    define BOOST_PP_ITERATION_2 15
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 14 && BOOST_PP_ITERATION_START_2 >= 14
#    define BOOST_PP_ITERATION_2 14
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 13 && BOOST_PP_ITERATION_START_2 >= 13
#    define BOOST_PP_ITERATION_2 13
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 12 && BOOST_PP_ITERATION_START_2 >= 12
#    define BOOST_PP_ITERATION_2 12
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 11 && BOOST_PP_ITERATION_START_2 >= 11
#    define BOOST_PP_ITERATION_2 11
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 10 && BOOST_PP_ITERATION_START_2 >= 10
#    define BOOST_PP_ITERATION_2 10
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 9 && BOOST_PP_ITERATION_START_2 >= 9
#    define BOOST_PP_ITERATION_2 9
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 8 && BOOST_PP_ITERATION_START_2 >= 8
#    define BOOST_PP_ITERATION_2 8
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 7 && BOOST_PP_ITERATION_START_2 >= 7
#    define BOOST_PP_ITERATION_2 7
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 6 && BOOST_PP_ITERATION_START_2 >= 6
#    define BOOST_PP_ITERATION_2 6
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 5 && BOOST_PP_ITERATION_START_2 >= 5
#    define BOOST_PP_ITERATION_2 5
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 4 && BOOST_PP_ITERATION_START_2 >= 4
#    define BOOST_PP_ITERATION_2 4
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 3 && BOOST_PP_ITERATION_START_2 >= 3
#    define BOOST_PP_ITERATION_2 3
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 2 && BOOST_PP_ITERATION_START_2 >= 2
#    define BOOST_PP_ITERATION_2 2
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 1 && BOOST_PP_ITERATION_START_2 >= 1
#    define BOOST_PP_ITERATION_2 1
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
# if BOOST_PP_ITERATION_FINISH_2 <= 0 && BOOST_PP_ITERATION_START_2 >= 0
#    define BOOST_PP_ITERATION_2 0
#    include BOOST_PP_FILENAME_2
#    undef BOOST_PP_ITERATION_2
# endif
",16249,True,7334.23589443358,median
"[[aggregator]]
=== Aggregator

Basically a mirror-image of the splitter, the aggregator is a type of message handler that receives multiple messages and combines them into a single message.
In fact, an aggregator is often a downstream consumer in a pipeline that includes a splitter.

Technically, the aggregator is more complex than a splitter, because it is stateful.
It must hold the messages to be aggregated and determine when the complete group of messages is ready to be aggregated.
In order to do so, it requires a `MessageStore`.

[[aggregator-functionality]]
==== Functionality

The Aggregator combines a group of related messages, by correlating and storing them, until the group is deemed to be complete.
At that point, the aggregator creates a single message by processing the whole group and sends the aggregated message as output.

Implementing an aggregator requires providing the logic to perform the aggregation (that is, the creation of a single message from many).
Two related concepts are correlation and release.

Correlation determines how messages are grouped for aggregation.
In Spring Integration, correlation is done by default, based on the `IntegrationMessageHeaderAccessor.CORRELATION_ID` message header.
Messages with the same `IntegrationMessageHeaderAccessor.CORRELATION_ID` are grouped together.
However, you can customize the correlation strategy to allow other ways of specifying how the messages should be grouped together.
To do so, you can implement a `CorrelationStrategy` (covered later in this chapter).

To determine the point at which a group of messages is ready to be processed, a `ReleaseStrategy` is consulted.
The default release strategy for the aggregator releases a group when all messages included in a sequence are present, based on the `IntegrationMessageHeaderAccessor.SEQUENCE_SIZE` header.
You can override this default strategy by providing a reference to a custom `ReleaseStrategy` implementation.

[[aggregator-api]]
==== Programming Model

The Aggregation API consists of a number of classes:

* The interface `MessageGroupProcessor`, and its subclasses: `MethodInvokingAggregatingMessageGroupProcessor` and `ExpressionEvaluatingMessageGroupProcessor`
* The `ReleaseStrategy` interface and its default implementation: `SimpleSequenceSizeReleaseStrategy`
* The `CorrelationStrategy` interface and its default implementation: `HeaderAttributeCorrelationStrategy`

===== `AggregatingMessageHandler`

The `AggregatingMessageHandler` (a subclass of `AbstractCorrelatingMessageHandler`) is a `MessageHandler` implementation, encapsulating the common functionality of an aggregator (and other correlating use cases), which are as follows:

* Correlating messages into a group to be aggregated
* Maintaining those messages in a `MessageStore` until the group can be released
* Deciding when the group can be released
* Aggregating the released group into a single message
* Recognizing and responding to an expired group

The responsibility for deciding how the messages should be grouped together is delegated to a `CorrelationStrategy` instance.
The responsibility for deciding whether the message group can be released is delegated to a `ReleaseStrategy` instance.

The following listing shows a brief highlight of the base `AbstractAggregatingMessageGroupProcessor` (the responsibility for implementing the `aggregatePayloads` method is left to the developer):

====
[source,java]
----
public abstract class AbstractAggregatingMessageGroupProcessor
              implements MessageGroupProcessor {

    protected Map<String, Object> aggregateHeaders(MessageGroup group) {
        // default implementation exists
    }

    protected abstract Object aggregatePayloads(MessageGroup group, Map<String, Object> defaultHeaders);

}
----
====

See `DefaultAggregatingMessageGroupProcessor`, `ExpressionEvaluatingMessageGroupProcessor` and `MethodInvokingMessageGroupProcessor` as out-of-the-box implementations of the `AbstractAggregatingMessageGroupProcessor`.

Starting with version 5.2, a `Function<MessageGroup, Map<String, Object>>` strategy is available for the `AbstractAggregatingMessageGroupProcessor` to merge and compute (aggregate) headers for an output message.
The `DefaultAggregateHeadersFunction` implementation is available with logic that returns all headers that have no conflicts among the group; an absent header on one or more messages within the group is not considered a conflict.
Conflicting headers are omitted.
Along with the newly introduced `DelegatingMessageGroupProcessor`, this function is used for any arbitrary (non-`AbstractAggregatingMessageGroupProcessor`) `MessageGroupProcessor` implementation.
Essentially, the framework injects a provided function into an `AbstractAggregatingMessageGroupProcessor` instance and wraps all other implementations into a `DelegatingMessageGroupProcessor`.
The difference in logic between the `AbstractAggregatingMessageGroupProcessor` and the `DelegatingMessageGroupProcessor` that the latter doesn't compute headers in advance, before calling the delegate strategy, and doesn't invoke the function if the delegate returns a `Message` or `AbstractIntegrationMessageBuilder`.
In that case, the framework assumes that the target implementation has taken care of producing a proper set of headers populated into the returned result.
The `Function<MessageGroup, Map<String, Object>>` strategy is available as the `headers-function` reference attribute for XML configuration, as the `AggregatorSpec.headersFunction()` option for the Java DSL and as `AggregatorFactoryBean.setHeadersFunction()` for plain Java configuration.

The `CorrelationStrategy` is owned by the `AbstractCorrelatingMessageHandler` and  has a default value based on the `IntegrationMessageHeaderAccessor.CORRELATION_ID` message header, as the following example shows:

====
[source,java]
----
public AbstractCorrelatingMessageHandler(MessageGroupProcessor processor, MessageGroupStore store,
        CorrelationStrategy correlationStrategy, ReleaseStrategy releaseStrategy) {
    ...
    this.correlationStrategy = correlationStrategy == null ?
        new HeaderAttributeCorrelationStrategy(IntegrationMessageHeaderAccessor.CORRELATION_ID) : correlationStrategy;
    this.releaseStrategy = releaseStrategy == null ? new SimpleSequenceSizeReleaseStrategy() : releaseStrategy;
    ...
}
----
====

As for the actual processing of the message group, the default implementation is the `DefaultAggregatingMessageGroupProcessor`.
It creates a single `Message` whose payload is a `List` of the payloads received for a given group.
This works well for simple scatter-gather implementations with a splitter, a publish-subscribe channel, or a recipient list router upstream.

NOTE: When using a publish-subscribe channel or a recipient list router in this type of scenario, be sure to enable the `apply-sequence` flag.
Doing so adds the necessary headers: `CORRELATION_ID`, `SEQUENCE_NUMBER`, and `SEQUENCE_SIZE`.
That behavior is enabled by default for splitters in Spring Integration, but it is not enabled for publish-subscribe channels or for recipient list routers because those components may be used in a variety of contexts in which these headers are not necessary.

When implementing a specific aggregator strategy for an application, you can extend `AbstractAggregatingMessageGroupProcessor` and implement the `aggregatePayloads` method.
However, there are better solutions, less coupled to the API, for implementing the aggregation logic, which can be configured either through XML or through annotations.

In general, any POJO can implement the aggregation algorithm if it provides a method that accepts a single `java.util.List` as an argument (parameterized lists are supported as well).
This method is invoked for aggregating messages as follows:

* If the argument is a `java.util.Collection<T>` and the parameter type T is assignable to `Message`, the whole list of messages accumulated for aggregation is sent to the aggregator.
* If the argument is a non-parameterized `java.util.Collection` or the parameter type is not assignable to `Message`, the method receives the payloads of the accumulated messages.
* If the return type is not assignable to `Message`, it is treated as the payload for a `Message` that is automatically created by the framework.

NOTE: In the interest of code simplicity and promoting best practices such as low coupling, testability, and others, the preferred way of implementing the aggregation logic is through a POJO and using the XML or annotation support for configuring it in the application.

Starting with version 5.3, after processing message group, an `AbstractCorrelatingMessageHandler` performs a `MessageBuilder.popSequenceDetails()` message headers modification for the proper splitter-aggregator scenario with several nested levels.
It is done only if the message group release result is not a collection of messages.
In that case a target `MessageGroupProcessor` is responsible for the `MessageBuilder.popSequenceDetails()` call while building those messages.

If the `MessageGroupProcessor` returns a `Message`, a `MessageBuilder.popSequenceDetails()` will be performed on the output message only if the `sequenceDetails` matches with first message in group.
(Previously this has been done only if a plain payload or an `AbstractIntegrationMessageBuilder` has been returned from the `MessageGroupProcessor`.)

This functionality can be controlled by a new `popSequence` `boolean` property, so the `MessageBuilder.popSequenceDetails()` can be disabled in some scenarios when correlation details have not been populated by the standard splitter.
This property, essentially, undoes what has been done by the nearest upstream `applySequence = true` in the `AbstractMessageSplitter`.
See <<./splitter.adoc#splitter,Splitter>> for more information.

[[agg-message-collection]]
IMPORTANT: The `SimpleMessageGroup.getMessages()` method returns an `unmodifiableCollection`.
Therefore, if your aggregating POJO method has a `Collection<Message>` parameter, the argument passed in is exactly that `Collection` instance and, when you use a `SimpleMessageStore` for the aggregator, that original `Collection<Message>` is cleared after releasing the group.
Consequently, the `Collection<Message>` variable in the POJO is cleared too, if it is passed out of the aggregator.
If you wish to simply release that collection as-is for further processing, you must build a new `Collection` (for example, `new ArrayList<Message>(messages)`).
Starting with version 4.3, the framework no longer copies the messages to a new collection, to avoid undesired extra object creation.


If the `processMessageGroup` method of the `MessageGroupProcessor` returns a collection, it must be a collection of `Message<?>` objects.
In this case, the messages are individually released.
Prior to version 4.2, it was not possible to provide a `MessageGroupProcessor` by using XML configuration.
Only POJO methods could be used for aggregation.
Now, if the framework detects that the referenced (or inner) bean implements `MessageProcessor`, it is used as the aggregator's output processor.

If you wish to release a collection of objects from a custom `MessageGroupProcessor` as the payload of a message, your class should extend `AbstractAggregatingMessageGroupProcessor` and implement `aggregatePayloads()`.

Also, since version 4.2, a `SimpleMessageGroupProcessor` is provided.
It returns the collection of messages from the group, which, as indicated earlier, causes the released messages to be sent individually.

This lets the aggregator work as a message barrier, where arriving messages are held until the release strategy fires and the group is released as a sequence of individual messages.

===== `ReleaseStrategy`

The `ReleaseStrategy` interface is defined as follows:

====
[source,java]
----
public interface ReleaseStrategy {

  boolean canRelease(MessageGroup group);

}
----
====

In general, any POJO can implement the completion decision logic if it provides a method that accepts a single `java.util.List` as an argument (parameterized lists are supported as well) and returns a boolean value.
This method is invoked after the arrival of each new message, to decide whether the group is complete or not, as follows:

* If the argument is a `java.util.List<T>` and the parameter type `T` is assignable to `Message`, the whole list of messages accumulated in the group is sent to the method.
* If the argument is a non-parametrized `java.util.List` or the parameter type is not assignable to `Message`, the method receives the payloads of the accumulated messages.
* The method must return `true` if the message group is ready for aggregation or false otherwise.

The following example shows how to use the `@ReleaseStrategy` annotation for a `List` of type `Message`:

====
[source,java]
----
public class MyReleaseStrategy {

    @ReleaseStrategy
    public boolean canMessagesBeReleased(List<Message<?>>) {...}
}
----
====

The following example shows how to use the `@ReleaseStrategy` annotation for a `List` of type `String`:

====
[source,java]
----
public class MyReleaseStrategy {

    @ReleaseStrategy
    public boolean canMessagesBeReleased(List<String>) {...}
}
----
====

Based on the signatures in the preceding two examples, the POJO-based release strategy is passed a `Collection` of not-yet-released messages (if you need access to the whole `Message`) or a `Collection` of payload objects (if the type parameter is anything other than `Message`).
This satisfies the majority of use cases.
However if, for some reason, you need to access the full `MessageGroup`, you should provide an implementation of the `ReleaseStrategy` interface.

[WARNING]
=====
When handling potentially large groups, you should understand how these methods are invoked, because the release strategy may be invoked multiple times before the group is released.
The most efficient is an implementation of `ReleaseStrategy`, because the aggregator can invoke it directly.
The second most efficient is a POJO method with a `Collection<Message<?>>` parameter type.
The least efficient is a POJO method with a `Collection<Something>` type.
The framework has to copy the payloads from the messages in the group into a new collection (and possibly attempt conversion on the payloads to `Something`) every time the release strategy is called.
Using `Collection<?>` avoids the conversion but still requires creating the new `Collection`.

For these reasons, for large groups, we recommended that you implement `ReleaseStrategy`.
=====

When the group is released for aggregation, all its not-yet-released messages are processed and removed from the group.
If the group is also complete (that is, if all messages from a sequence have arrived or if there is no sequence defined), then the group is marked as complete.
Any new messages for this group are sent to the discard channel (if defined).
Setting `expire-groups-upon-completion` to `true` (the default is `false`) removes the entire group, and any new messages (with the same correlation ID as the removed group) form a new group.
You can release partial sequences by using a `MessageGroupStoreReaper` together with `send-partial-result-on-expiry` being set to `true`.

IMPORTANT: To facilitate discarding of late-arriving messages, the aggregator must maintain state about the group after it has been released.
This can eventually cause out-of-memory conditions.
To avoid such situations, you should consider configuring a `MessageGroupStoreReaper` to remove the group metadata.
The expiry parameters should be set to expire groups once a point has been reach after after which late messages are not expected to arrive.
For information about configuring a reaper, see <<reaper>>.

Spring Integration provides an implementation for `ReleaseStrategy`: `SimpleSequenceSizeReleaseStrategy`.
This implementation consults the `SEQUENCE_NUMBER` and `SEQUENCE_SIZE` headers of each arriving message to decide when a message group is complete and ready to be aggregated.
As shown earlier, it is also the default strategy.

NOTE: Before version 5.0, the default release strategy was `SequenceSizeReleaseStrategy`, which does not perform well with large groups.
With that strategy, duplicate sequence numbers are detected and rejected.
This operation can be expensive.

If you are aggregating large groups, you don't need to release partial groups, and you don't need to detect/reject duplicate sequences, consider using the `SimpleSequenceSizeReleaseStrategy` instead - it is much more efficient for these use cases, and is the default since _version 5.0_ when partial group release is not specified.

===== Aggregating Large Groups

The 4.3 release changed the default `Collection` for messages in a `SimpleMessageGroup` to `HashSet` (it was previously a `BlockingQueue`).
This was expensive when removing individual messages from large groups (an O(n) linear scan was required).
Although the hash set is generally much faster to remove, it can be expensive for large messages, because the hash has to be calculated on both inserts and removes.
If you have messages that are expensive to hash, consider using some other collection type.
As discussed in <<./message-store.adoc#message-group-factory,Using `MessageGroupFactory`>>, a `SimpleMessageGroupFactory` is provided so that you can select the `Collection` that best suits your needs.
You can also provide your own factory implementation to create some other `Collection<Message<?>>`.

The following example shows how to configure an aggregator with the previous implementation and a `SimpleSequenceSizeReleaseStrategy`:

====
[source, xml]
----
<int:aggregator input-channel=""aggregate""
    output-channel=""out"" message-store=""store"" release-strategy=""releaser"" />

<bean id=""store"" class=""org.springframework.integration.store.SimpleMessageStore"">
    <property name=""messageGroupFactory"">
        <bean class=""org.springframework.integration.store.SimpleMessageGroupFactory"">
            <constructor-arg value=""BLOCKING_QUEUE""/>
        </bean>
    </property>
</bean>

<bean id=""releaser"" class=""SimpleSequenceSizeReleaseStrategy"" />
----
====

===== Correlation Strategy

The `CorrelationStrategy` interface is defined as follows:

====
[source,java]
----
public interface CorrelationStrategy {

  Object getCorrelationKey(Message<?> message);

}
----
====

The method returns an `Object` that represents the correlation key used for associating the message with a message group.
The key must satisfy the criteria used for a key in a `Map` with respect to the implementation of `equals()` and `hashCode()`.

In general, any POJO can implement the correlation logic, and the rules for mapping a message to a method's argument (or arguments) are the same as for a `ServiceActivator` (including support for `@Header` annotations).
The method must return a value, and the value must not be `null`.

Spring Integration provides an implementation for `CorrelationStrategy`: `HeaderAttributeCorrelationStrategy`.
This implementation returns the value of one of the message headers (whose name is specified by a constructor argument) as the correlation key.
By default, the correlation strategy is a `HeaderAttributeCorrelationStrategy` that returns the value of the `CORRELATION_ID` header attribute.
If you have a custom header name you would like to use for correlation, you can configure it on an instance of `HeaderAttributeCorrelationStrategy` and provide that as a reference for the aggregator's correlation strategy.

===== Lock Registry

Changes to groups are thread safe.
So, when you send messages for the same correlation ID concurrently, only one of them will be processed in the aggregator, making it effectively as a *single-threaded per message group*.
A `LockRegistry` is used to obtain a lock for the resolved correlation ID.
A `DefaultLockRegistry` is used by default (in-memory).
For synchronizing updates across servers where a shared `MessageGroupStore` is being used, you must configure a shared lock registry.

[[aggregator-deadlocks]]
===== Avoiding Deadlocks

As discussed above, when message groups are mutated (messages added or released) a lock is held.

Consider the following flow:

====
[source]
----
...->aggregator1-> ... ->aggregator2-> ...
----
====

If there are multiple threads, **and the aggregators share a common lock registry**, it is possible to get a deadlock.
This will cause hung threads and `jstack <pid>` might present a result such as:

====
[source]
----
Found one Java-level deadlock:
=============================
""t2"":
  waiting for ownable synchronizer 0x000000076c1cbfa0, (a java.util.concurrent.locks.ReentrantLock$NonfairSync),
  which is held by ""t1""
""t1"":
  waiting for ownable synchronizer 0x000000076c1ccc00, (a java.util.concurrent.locks.ReentrantLock$NonfairSync),
  which is held by ""t2""
----
====

There are several ways to avoid this problem:

* ensure each aggregator has its own lock registry (this can be a shared registry across application instances but two or more aggregators in the flow must each have a distinct registry)
* use an `ExecutorChannel` or `QueueChannel` as the output channel of the aggregator so that the downstream flow runs on a new thread
* starting with version 5.1.1, set the `releaseLockBeforeSend` aggregator property to `true`

NOTE: This problem can also be caused if, for some reason, the output of a single aggregator is eventually routed back to the same aggregator.
Of course, the first solution above does not apply in this case.


[[aggregator-java-dsl]]
==== Configuring an Aggregator in Java DSL

See <<./dsl.adoc#java-dsl-aggregators,Aggregators and Resequencers>> for how to configure an aggregator in Java DSL.

[[aggregator-xml]]
===== Configuring an Aggregator with XML

Spring Integration supports the configuration of an aggregator with XML through the `<aggregator/>` element.
The following example shows an example of an aggregator:

====
[source,xml]
----
<channel id=""inputChannel""/>

<int:aggregator id=""myAggregator""                          <1>
        auto-startup=""true""                                <2>
        input-channel=""inputChannel""                       <3>
        output-channel=""outputChannel""                     <4>
        discard-channel=""throwAwayChannel""                 <5>
        message-store=""persistentMessageStore""             <6>
        order=""1""                                          <7>
        send-partial-result-on-expiry=""false""              <8>
        send-timeout=""1000""                                <9>

        correlation-strategy=""correlationStrategyBean""     <10>
        correlation-strategy-method=""correlate""            <11>
        correlation-strategy-expression=""headers['foo']""   <12>

        ref=""aggregatorBean""                               <13>
        method=""aggregate""                                 <14>

        release-strategy=""releaseStrategyBean""             <15>
        release-strategy-method=""release""                  <16>
        release-strategy-expression=""size() == 5""          <17>

        expire-groups-upon-completion=""false""              <18>
        empty-group-min-timeout=""60000""                    <19>

        lock-registry=""lockRegistry""                       <20>

        group-timeout=""60000""                              <21>
        group-timeout-expression=""size() ge 2 ? 100 : -1""  <22>
        expire-groups-upon-timeout=""true""                  <23>

        scheduler=""taskScheduler"" >                        <24>
            <expire-transactional/>                        <25>
            <expire-advice-chain/>                         <26>
</aggregator>

<int:channel id=""outputChannel""/>

<int:channel id=""throwAwayChannel""/>

<bean id=""persistentMessageStore"" class=""org.springframework.integration.jdbc.store.JdbcMessageStore"">
    <constructor-arg ref=""dataSource""/>
</bean>

<bean id=""aggregatorBean"" class=""sample.PojoAggregator""/>

<bean id=""releaseStrategyBean"" class=""sample.PojoReleaseStrategy""/>

<bean id=""correlationStrategyBean"" class=""sample.PojoCorrelationStrategy""/>
----

<1> The id of the aggregator is optional.
<2> Lifecycle attribute signaling whether the aggregator should be started during application context startup.
Optional (the default is 'true').
<3> The channel from which where aggregator receives messages.
Required.
<4> The channel to which the aggregator sends the aggregation results.
Optional (because incoming messages can themselves specify a reply channel in the 'replyChannel' message header).
<5> The channel to which the aggregator sends the messages that timed out (if `send-partial-result-on-expiry` is `false`).
Optional.
<6> A reference to a `MessageGroupStore` used to store groups of messages under their correlation key until they are complete.
Optional.
By default, it is a volatile in-memory store.
See <<./message-store.adoc#message-store,Message Store>> for more information.
<7> The order of this aggregator when more than one handle is subscribed to the same `DirectChannel` (use for load-balancing purposes).
Optional.
<8> Indicates that expired messages should be aggregated and sent to the 'output-channel' or 'replyChannel' once their containing `MessageGroup` is expired (see https://docs.spring.io/spring-integration/api/org/springframework/integration/store/MessageGroupStore.html#expireMessageGroups-long[`MessageGroupStore.expireMessageGroups(long)`]).
One way of expiring a `MessageGroup` is by configuring a `MessageGroupStoreReaper`.
However you can alternatively expire `MessageGroup` by calling `MessageGroupStore.expireMessageGroups(timeout)`.
You can accomplish that through a Control Bus operation or, if you have a reference to the `MessageGroupStore` instance, by invoking `expireMessageGroups(timeout)`.
Otherwise, by itself, this attribute does nothing.
It serves only as an indicator of whether to discard or send to the output or reply channel any messages that are still in the `MessageGroup` that is about to be expired.
Optional (the default is `false`).
NOTE: This attribute might more properly be called `send-partial-result-on-timeout`, because the group may not actually expire if `expire-groups-upon-timeout` is set to `false`.
<9> The timeout interval to wait when sending a reply `Message` to the `output-channel` or `discard-channel`.
Defaults to `-1`, which results in blocking indefinitely.
It is applied only if the output channel has some 'sending' limitations, such as a `QueueChannel` with a fixed 'capacity'.
In this case, a `MessageDeliveryException` is thrown.
For `AbstractSubscribableChannel` implementations, the `send-timeout` is ignored .
For `group-timeout(-expression)`, the `MessageDeliveryException` from the scheduled expire task leads this task to be rescheduled.
Optional.
<10> A reference to a bean that implements the message correlation (grouping) algorithm.
The bean can be an implementation of the `CorrelationStrategy` interface or a POJO.
In the latter case, the `correlation-strategy-method` attribute must be defined as well.
Optional (by default, the aggregator uses the `IntegrationMessageHeaderAccessor.CORRELATION_ID` header).
<11> A method defined on the bean referenced by `correlation-strategy`.
It implements the correlation decision algorithm.
Optional, with restrictions (`correlation-strategy` must be present).
<12> A SpEL expression representing the correlation strategy.
Example: `""headers['something']""`.
Only one of `correlation-strategy` or `correlation-strategy-expression` is allowed.
<13> A reference to a bean defined in the application context.
The bean must implement the aggregation logic, as described earlier.
Optional (by default, the list of aggregated messages becomes a payload of the output message).
<14> A method defined on the bean referenced by the `ref` attribute.
It implements the message aggregation algorithm.
Optional (it depends on `ref` attribute being defined).
<15> A reference to a bean that implements the release strategy.
The bean can be an implementation of the `ReleaseStrategy` interface or a POJO.
In the latter case, the `release-strategy-method` attribute must be defined as well.
Optional (by default, the aggregator uses the `IntegrationMessageHeaderAccessor.SEQUENCE_SIZE` header attribute).
<16> A method defined on the bean referenced by the `release-strategy` attribute.
It implements the completion decision algorithm.
Optional, with restrictions (`release-strategy` must be present).
<17> A SpEL expression representing the release strategy.
The root object for the expression is a `MessageGroup`.
Example: `""size() == 5""`.
Only one of `release-strategy` or `release-strategy-expression` is allowed.
<18> When set to `true` (the default is `false`), completed groups are removed from the message store, letting subsequent messages with the same correlation form a new group.
The default behavior is to send messages with the same correlation as a completed group to the `discard-channel`.
<19> Applies only if a `MessageGroupStoreReaper` is configured for the `MessageStore` of the `<aggregator>`.
By default, when a `MessageGroupStoreReaper` is configured to expire partial groups, empty groups are also removed.
Empty groups exist after a group is normally released.
The empty groups enable the detection and discarding of late-arriving messages.
If you wish to expire empty groups on a longer schedule than expiring partial groups, set this property.
Empty groups are then not removed from the `MessageStore` until they have not been modified for at least this number of milliseconds.
Note that the actual time to expire an empty group is also affected by the reaper's `timeout` property, and it could be as much as this value plus the timeout.
<20> A reference to a `org.springframework.integration.util.LockRegistry` bean.
It used to obtain a `Lock` based on the `groupId` for concurrent operations on the `MessageGroup`.
By default, an internal `DefaultLockRegistry` is used.
Use of a distributed `LockRegistry`, such as the `ZookeeperLockRegistry`, ensures only one instance of the aggregator can operate on a group concurrently.
See <<./redis.adoc#redis-lock-registry,Redis Lock Registry>>, <<./gemfire.adoc#gemfire-lock-registry,Gemfire Lock Registry>>, and <<./zookeeper.adoc#zk-lock-registry,Zookeeper Lock Registry>> for more information.
<21> A timeout (in milliseconds) to force the `MessageGroup` complete when the `ReleaseStrategy` does not release the group when the current message arrives.
This attribute provides a built-in time-based release strategy for the aggregator when there is a need to emit a partial result (or discard the group) if a new message does not arrive for the `MessageGroup` within the timeout which counts from the time the last message arrived.
To set up a timeout which counts from the time the `MessageGroup` was created see `group-timeout-expression` information.
When a new message arrives at the aggregator, any existing `ScheduledFuture<?>` for its `MessageGroup` is canceled.
If the `ReleaseStrategy` returns `false` (meaning do not release) and `groupTimeout > 0`, a new task is scheduled to expire the group.
We do not advise setting this attribute to zero (or a negative value).
Doing so effectively disables the aggregator, because every message group is immediately completed.
You can, however, conditionally set it to zero (or a negative value) by using an expression.
See `group-timeout-expression` for information.
The action taken during the completion depends on the `ReleaseStrategy` and the `send-partial-group-on-expiry` attribute.
See <<agg-and-group-to>> for more information.
It is mutually exclusive with 'group-timeout-expression' attribute.
<22> The SpEL expression that evaluates to a `groupTimeout` with the `MessageGroup` as the `#root` evaluation context object.
Used for scheduling the `MessageGroup` to be forced complete.
If the expression evaluates to `null`, the completion is not scheduled.
If it evaluates to zero, the group is completed immediately on the current thread.
In effect, this provides a dynamic `group-timeout` property.
As an example, if you wish to forcibly complete a `MessageGroup` after 10 seconds have elapsed since the time the group was created you might consider using the following SpEL expression: `timestamp + 10000 - T(System).currentTimeMillis()` where `timestamp` is provided by `MessageGroup.getTimestamp()` as the `MessageGroup` here is the `#root` evaluation context object.
Bear in mind however that the group creation time might differ from the time of the first arrived message depending on other group expiration properties' configuration.
See `group-timeout` for more information.
Mutually exclusive with 'group-timeout' attribute.
<23> When a group is completed due to a timeout (or by a `MessageGroupStoreReaper`), the group is expired (completely removed) by default.
Late arriving messages start a new group.
You can set this to `false` to complete the group but have its metadata remain so that late arriving messages are discarded.
Empty groups can be expired later using a `MessageGroupStoreReaper` together with the `empty-group-min-timeout` attribute.
It defaults to 'true'.
<24> A `TaskScheduler` bean reference to schedule the `MessageGroup` to be forced complete if no new message arrives for the `MessageGroup` within the `groupTimeout`.
If not provided, the default scheduler (`taskScheduler`) registered in the `ApplicationContext` (`ThreadPoolTaskScheduler`) is used.
This attribute does not apply if `group-timeout` or `group-timeout-expression` is not specified.
<25> Since version 4.1.
It lets a transaction be started for the `forceComplete` operation.
It is initiated from a `group-timeout(-expression)` or by a `MessageGroupStoreReaper` and is not applied to the normal `add`, `release`, and `discard` operations.
Only this sub-element or `<expire-advice-chain/>` is allowed.
<26> Since _version 4.1_.
It allows the configuration of any `Advice` for the `forceComplete` operation.
It is initiated from a `group-timeout(-expression)` or by a `MessageGroupStoreReaper` and is not applied to the normal `add`, `release`, and `discard` operations.
Only this sub-element or `<expire-transactional/>` is allowed.
A transaction `Advice` can also be configured here by using the Spring `tx` namespace.
====

[[aggregator-expiring-groups]]
[IMPORTANT]
.Expiring Groups
=====
There are two attributes related to expiring (completely removing) groups.
When a group is expired, there is no record of it, and, if a new message arrives with the same correlation, a new group is started.
When a group is completed (without expiry), the empty group remains and late-arriving messages are discarded.
Empty groups can be removed later by using a `MessageGroupStoreReaper` in combination with the `empty-group-min-timeout` attribute.

`expire-groups-upon-completion` relates to ""`normal`"" completion when the `ReleaseStrategy` releases the group.
This defaults to `false`.

If a group is not completed normally but is released or discarded because of a timeout, the group is normally expired.
Since version 4.1, you can control this behavior by using `expire-groups-upon-timeout`.
It defaults to `true` for backwards compatibility.

NOTE: When a group is timed out, the `ReleaseStrategy` is given one more opportunity to release the group.
If it does so and `expire-groups-upon-timeout` is false, expiration is controlled by `expire-groups-upon-completion`.
If the group is not released by the release strategy during timeout, then the expiration is controlled by the `expire-groups-upon-timeout`.
Timed-out groups are either discarded or a partial release occurs (based on `send-partial-result-on-expiry`).

Since version 5.0, empty groups are also scheduled for removal after `empty-group-min-timeout`.
If `expireGroupsUponCompletion == false` and `minimumTimeoutForEmptyGroups > 0`, the task to remove the group is scheduled when normal or partial sequences release happens.

Starting with version 5.4, the aggregator (and resequencer) can be configured to expire orphaned groups (groups in a persistent message store that might not otherwise be released).
The `expireTimeout` (if greater than `0`) indicates that groups older than this value in the store should be purged.
The `purgeOrphanedGroups()` method is called on start up and, together with the provided `expireDuration`, periodically within a scheduled task.
This method is also can be called externally at any time.
The expiration logic is fully delegated to the `forceComplete(MessageGroup)` functionality according to the provided expiration options mentioned above.
Such a periodic purge functionality is useful when a message store is needed to be cleaned up from those old groups which are not going to be released any more with regular message arrival logic.
In most cases this happens after an application restart, when using a persistent message group store.
The functionality is similar to the `MessageGroupStoreReaper` with a scheduled task, but provides a convenient way to deal with old groups within specific components, when using group timeout instead of a reaper.
The `MessageGroupStore` must be provided exclusively for the current correlation endpoint.
Otherwise one aggregator may purge groups from another.
With the aggregator, groups expired using this technique will either be discarded or released as a partial group, depending on the `expireGroupsUponCompletion` property.
=====

We generally recommend using a `ref` attribute if a custom aggregator handler implementation may be referenced in other `<aggregator>` definitions.
However, if a custom aggregator implementation is only being used by a single definition of the `<aggregator>`, you can use an inner bean definition (starting with version 1.0.3) to configure the aggregation POJO within the `<aggregator>` element, as the following example shows:

====
[source,xml]
----
<aggregator input-channel=""input"" method=""sum"" output-channel=""output"">
    <beans:bean class=""org.foo.PojoAggregator""/>
</aggregator>
----
====

NOTE: Using both a `ref` attribute and an inner bean definition in the same `<aggregator>` configuration is not allowed, as it creates an ambiguous condition.
In such cases, an Exception is thrown.

The following example shows an implementation of the aggregator bean:

====
[source,java]
----
public class PojoAggregator {

  public Long add(List<Long> results) {
    long total = 0l;
    for (long partialResult: results) {
      total += partialResult;
    }
    return total;
  }
}
----
====

An implementation of the completion strategy bean for the preceding example might be as follows:

====
[source,java]
----
public class PojoReleaseStrategy {
...
  public boolean canRelease(List<Long> numbers) {
    int sum = 0;
    for (long number: numbers) {
      sum += number;
    }
    return sum >= maxValue;
  }
}
----
====

NOTE: Wherever it makes sense to do so, the release strategy method and the aggregator method can be combined into a single bean.

An implementation of the correlation strategy bean for the example above might be as follows:

====
[source,java]
----
public class PojoCorrelationStrategy {
...
  public Long groupNumbersByLastDigit(Long number) {
    return number % 10;
  }
}
----
====

The aggregator in the preceding example would group numbers by some criterion (in this case, the remainder after dividing by ten) and hold the group until the sum of the numbers provided by the payloads exceeds a certain value.

NOTE: Wherever it makes sense to do so, the release strategy method, the correlation strategy method, and the aggregator method can be combined in a single bean.
(Actually, all of them or any two of them can be combined.)

[[aggregator-spel]]
====== Aggregators and Spring Expression Language (SpEL)

Since Spring Integration 2.0, you can handle the various strategies (correlation, release, and aggregation) with https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#expressions[SpEL], which we recommend if the logic behind such a release strategy is relatively simple.
Suppose you have a legacy component that was designed to receive an array of objects.
We know that the default release strategy assembles all aggregated messages in the `List`.
Now we have two problems.
First, we need to extract individual messages from the list.
Second, we need to extract the payload of each message and assemble the array of objects.
The following example solves both problems:

====
[source,java]
----
public String[] processRelease(List<Message<String>> messages){
    List<String> stringList = new ArrayList<String>();
    for (Message<String> message : messages) {
        stringList.add(message.getPayload());
    }
    return stringList.toArray(new String[]{});
}
----
====

However, with SpEL, such a requirement could actually be handled relatively easily with a one-line expression, thus sparing you from writing a custom class and configuring it as a bean.
The following example shows how to do so:

====
[source,xml]
----
<int:aggregator input-channel=""aggChannel""
    output-channel=""replyChannel""
    expression=""#this.![payload].toArray()""/>
----
====

In the preceding configuration, we use a https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#expressions[collection projection] expression to assemble a new collection from the payloads of all the messages in the list and then transform it to an array, thus achieving the same result as the earlier Java code.

You can apply the same expression-based approach when dealing with custom release and correlation strategies.

Instead of defining a bean for a custom `CorrelationStrategy` in the `correlation-strategy` attribute, you can implement your simple correlation logic as a SpEL expression and configure it in the `correlation-strategy-expression` attribute, as the following example shows:

====
[source,xml]
----
correlation-strategy-expression=""payload.person.id""
----
====

In the preceding example, we assume that the payload has a `person` attribute with an `id`, which is going to be used to correlate messages.

Likewise, for the `ReleaseStrategy`, you can implement your release logic as a SpEL expression and configure it in the `release-strategy-expression` attribute.
The root object for evaluation context is the `MessageGroup` itself.
The `List` of messages can be referenced by using the `message` property of the group within the expression.

NOTE: In releases prior to version 5.0, the root object was the collection of `Message<?>`, as the previous example shows:

====
[source,xml]
----
release-strategy-expression=""!messages.?[payload==5].empty""
----
====

In the preceding example, the root object of the SpEL evaluation context is the `MessageGroup` itself, and you are stating that, as soon as there is a message with payload of `5` in this group, the group should be released.

[[agg-and-group-to]]
====== Aggregator and Group Timeout

Starting with version 4.0, two new mutually exclusive attributes have been introduced: `group-timeout` and `group-timeout-expression`.
See <<aggregator-xml>>.
In some cases, you may need to emit the aggregator result (or discard the group) after a timeout if the `ReleaseStrategy` does not release when the current message arrives.
For this purpose, the `groupTimeout` option lets scheduling the `MessageGroup` be forced to complete, as the following example shows:

====
[source,xml]
----
<aggregator input-channel=""input"" output-channel=""output""
        send-partial-result-on-expiry=""true""
        group-timeout-expression=""size() ge 2 ? 10000 : -1""
        release-strategy-expression=""messages[0].headers.sequenceNumber == messages[0].headers.sequenceSize""/>
----
====

With this example, the normal release is possible if the aggregator receives the last message in sequence as defined by the `release-strategy-expression`.
If that specific message does not arrive, the `groupTimeout` forces the group to complete after ten seconds, as long as the group contains at least two Messages.

The results of forcing the group to complete depends on the `ReleaseStrategy` and the `send-partial-result-on-expiry`.
First, the release strategy is again consulted to see if a normal release is to be made.
While the group has not changed, the `ReleaseStrategy` can decide to release the group at this time.
If the release strategy still does not release the group, it is expired.
If `send-partial-result-on-expiry` is `true`, existing messages in the (partial) `MessageGroup` are released as a normal aggregator reply message to the `output-channel`.
Otherwise, it is discarded.

There is a difference between `groupTimeout` behavior and `MessageGroupStoreReaper` (see <<aggregator-xml>>).
The reaper initiates forced completion for all `MessageGroup` s in the `MessageGroupStore` periodically.
The `groupTimeout` does it for each `MessageGroup` individually if a new message does not arrive during the `groupTimeout`.
Also, the reaper can be used to remove empty groups (empty groups are retained in order to discard late messages if `expire-groups-upon-completion` is false).

Starting with version 5.5, the `groupTimeoutExpression` can be evaluated to a `java.util.Date` instance.
This can be useful in cases like determining a scheduled task moment based on the group creation time (`MessageGroup.getTimestamp()`) instead of a current message arrival as it is calculated when `groupTimeoutExpression` is evaluated to `long`:

====
[source,xml]
----
group-timeout-expression=""size() ge 2 ? new java.util.Date(timestamp + 200) : null""
----
====

[[aggregator-annotations]]
===== Configuring an Aggregator with Annotations

The following example shows an aggregator configured with annotations:

====
[source,java]
----
public class Waiter {
  ...

  @Aggregator  <1>
  public Delivery aggregatingMethod(List<OrderItem> items) {
    ...
  }

  @ReleaseStrategy  <2>
  public boolean releaseChecker(List<Message<?>> messages) {
    ...
  }

  @CorrelationStrategy  <3>
  public String correlateBy(OrderItem item) {
    ...
  }
}
----

<1> An annotation indicating that this method should be used as an aggregator.
It must be specified if this class is used as an aggregator.
<2> An annotation indicating that this method is used as the release strategy of an aggregator.
If not present on any method, the aggregator uses the `SimpleSequenceSizeReleaseStrategy`.
<3> An annotation indicating that this method should be used as the correlation strategy of an aggregator.
If no correlation strategy is indicated, the aggregator uses the `HeaderAttributeCorrelationStrategy` based on `CORRELATION_ID`.
====

All of the configuration options provided by the XML element are also available for the `@Aggregator` annotation.

The aggregator can be either referenced explicitly from XML or, if the `@MessageEndpoint` is defined on the class, detected automatically through classpath scanning.

Annotation configuration (`@Aggregator` and others) for the Aggregator component covers only simple use cases, where most default options are sufficient.
If you need more control over those options when using annotation configuration, consider using a `@Bean` definition for the `AggregatingMessageHandler` and mark its `@Bean` method with `@ServiceActivator`, as the following example shows:

====
[source,java]
----
@ServiceActivator(inputChannel = ""aggregatorChannel"")
@Bean
public MessageHandler aggregator(MessageGroupStore jdbcMessageGroupStore) {
     AggregatingMessageHandler aggregator =
                       new AggregatingMessageHandler(new DefaultAggregatingMessageGroupProcessor(),
                                                 jdbcMessageGroupStore);
     aggregator.setOutputChannel(resultsChannel());
     aggregator.setGroupTimeoutExpression(new ValueExpression<>(500L));
     aggregator.setTaskScheduler(this.taskScheduler);
     return aggregator;
}
----
====

See <<aggregator-api>> and <<./configuration.adoc#annotations_on_beans,Annotations on `@Bean` Methods>> for more information.

NOTE: Starting with version 4.2, the `AggregatorFactoryBean` is available to simplify Java configuration for the `AggregatingMessageHandler`.

[[reaper]]
==== Managing State in an Aggregator: `MessageGroupStore`

Aggregator (and some other patterns in Spring Integration) is a stateful pattern that requires decisions to be made based on a group of messages that have arrived over a period of time, all with the same correlation key.
The design of the interfaces in the stateful patterns (such as `ReleaseStrategy`) is driven by the principle that the components (whether defined by the framework or by a user) should be able to remain stateless.
All state is carried by the `MessageGroup` and its management is delegated to the `MessageGroupStore`.
The `MessageGroupStore` interface is defined as follows:

====
[source,java]
----
public interface MessageGroupStore {

    int getMessageCountForAllMessageGroups();

    int getMarkedMessageCountForAllMessageGroups();

    int getMessageGroupCount();

    MessageGroup getMessageGroup(Object groupId);

    MessageGroup addMessageToGroup(Object groupId, Message<?> message);

    MessageGroup markMessageGroup(MessageGroup group);

    MessageGroup removeMessageFromGroup(Object key, Message<?> messageToRemove);

    MessageGroup markMessageFromGroup(Object key, Message<?> messageToMark);

    void removeMessageGroup(Object groupId);

    void registerMessageGroupExpiryCallback(MessageGroupCallback callback);

    int expireMessageGroups(long timeout);
}
----
====

For more information, see the https://docs.spring.io/spring-integration/api/org/springframework/integration/store/MessageGroupStore.html[Javadoc].

The `MessageGroupStore` accumulates state information in `MessageGroups` while waiting for a release strategy to be triggered, and that event might not ever happen.
So, to prevent stale messages from lingering, and for volatile stores to provide a hook for cleaning up when the application shuts down, the `MessageGroupStore` lets you register callbacks to apply to its `MessageGroups` when they expire.
The interface is very straightforward, as the following listing shows:

====
[source,java]
----
public interface MessageGroupCallback {

    void execute(MessageGroupStore messageGroupStore, MessageGroup group);

}
----
====

The callback has direct access to the store and the message group so that it can manage the persistent state (for example, by entirely removing the group from the store).

The `MessageGroupStore` maintains a list of these callbacks, which it applies, on demand, to all messages whose timestamps are earlier than a time supplied as a parameter (see the `registerMessageGroupExpiryCallback(..)` and `expireMessageGroups(..)` methods, described earlier).
For more detail, see <<reaper>>.

IMPORTANT: It is important not to use the same `MessageGroupStore` instance in different aggregator components, when you intend to rely on the `expireMessageGroups` functionality.
Every `AbstractCorrelatingMessageHandler` registers its own `MessageGroupCallback` based on the `forceComplete()` callback.
This way each group for expiration may be completed or discarded by the wrong aggregator.
Starting with version 5.0.10, a `UniqueExpiryCallback` is used from the `AbstractCorrelatingMessageHandler` for the registration callback in the `MessageGroupStore`.
The `MessageGroupStore`, in turn, checks for presence an instance of this class and logs an error with an appropriate message if one is already present in the callbacks set.
This way the Framework disallows usage of the `MessageGroupStore` instance in different aggregators/resequencers to avoid the mentioned side effect of expiration the groups not created by the particular correlation handler.

You can call the `expireMessageGroups` method with a timeout value.
Any message older than the current time minus this value is expired and has the callbacks applied.
Thus, it is the user of the store that defines what is meant by message group ""`expiry`"".

As a convenience for users, Spring Integration provides a wrapper for the message expiry in the form of a `MessageGroupStoreReaper`, as the following example shows:

====
[source,xml]
----
<bean id=""reaper"" class=""org...MessageGroupStoreReaper"">
    <property name=""messageGroupStore"" ref=""messageStore""/>
    <property name=""timeout"" value=""30000""/>
</bean>

<task:scheduled-tasks scheduler=""scheduler"">
    <task:scheduled ref=""reaper"" method=""run"" fixed-rate=""10000""/>
</task:scheduled-tasks>
----
====

The reaper is a `Runnable`.
In the preceding example, the message group store's expire method is called every ten seconds.
The timeout itself is 30 seconds.

NOTE: It is important to understand that the 'timeout' property of `MessageGroupStoreReaper` is an approximate value and is impacted by the the rate of the task scheduler, since this property is only checked on the next scheduled execution of the `MessageGroupStoreReaper` task.
For example, if the timeout is set for ten minutes but the `MessageGroupStoreReaper` task is scheduled to run every hour and the last execution of the `MessageGroupStoreReaper` task happened one minute before the timeout, the `MessageGroup` does not expire for the next 59 minutes.
Consequently, we recommend setting the rate to be at least equal to the value of the timeout or shorter.

In addition to the reaper, the expiry callbacks are invoked when the application shuts down through a lifecycle callback in the `AbstractCorrelatingMessageHandler`.

The `AbstractCorrelatingMessageHandler` registers its own expiry callback, and this is the link with the boolean flag `send-partial-result-on-expiry` in the XML configuration of the aggregator.
If the flag is set to `true`, then, when the expiry callback is invoked, any unmarked messages in groups that are not yet released can be sent on to the output channel.

[IMPORTANT]
=====
When a shared `MessageStore` is used for different correlation endpoints, you must configure a proper `CorrelationStrategy` to ensure uniqueness for group IDs.
Otherwise, unexpected behavior may happen when one correlation endpoint releases or expire messages from others.
Messages with the same correlation key are stored in the same message group.

Some `MessageStore` implementations allow using the same physical resources, by partitioning the data.
For example, the `JdbcMessageStore` has a `region` property, and the `MongoDbMessageStore` has a `collectionName` property.

For more information about the `MessageStore` interface and its implementations, see <<./message-store.adoc#message-store,Message Store>>.
=====

[[flux-aggregator]]
==== Flux Aggregator

In version 5.2, the `FluxAggregatorMessageHandler` component has been introduced.
It is based on the Project Reactor `Flux.groupBy()` and `Flux.window()` operators.
The incoming messages are emitted into the `FluxSink` initiated by the `Flux.create()` in the constructor of this component.
If the `outputChannel` is not provided or it is not an instance of `ReactiveStreamsSubscribableChannel`, the subscription to the main `Flux` is done from the `Lifecycle.start()` implementation.
Otherwise it is postponed to the subscription done by the `ReactiveStreamsSubscribableChannel` implementation.
The messages are grouped by the `Flux.groupBy()` using a `CorrelationStrategy` for the group key.
By default, the `IntegrationMessageHeaderAccessor.CORRELATION_ID` header of the message is consulted.

By default every closed window is released as a `Flux` in payload of a message to produce.
This message contains all the headers from the first message in the window.
This `Flux` in the output message payload must be subscribed and processed downstream.
Such a logic can be customized (or superseded) by the `setCombineFunction(Function<Flux<Message<?>>, Mono<Message<?>>>)` configuration option of the `FluxAggregatorMessageHandler`.
For example, if we would like to have a `List` of payloads in the final message, we can configure a `Flux.collectList()` like this:

====
[source,java]
----
fluxAggregatorMessageHandler.setCombineFunction(
                (messageFlux) ->
                        messageFlux
                                .map(Message::getPayload)
                                .collectList()
                                .map(GenericMessage::new));
----
====

There are several options in the `FluxAggregatorMessageHandler` to select an appropriate window strategy:

* `setBoundaryTrigger(Predicate<Message<?>>)` - is propagated to the `Flux.windowUntil()` operator.
See its JavaDocs for more information.
Has a precedence over all other window options.
* `setWindowSize(int)` and `setWindowSizeFunction(Function<Message<?>, Integer>)` - is propagated to the `Flux.window(int)` or `windowTimeout(int, Duration)`.
By default a window size is calculated from the first message in group and its `IntegrationMessageHeaderAccessor.SEQUENCE_SIZE` header.
* `setWindowTimespan(Duration)` - is propagated to the `Flux.window(Duration)` or `windowTimeout(int, Duration)` depending in the window size configuration.
* `setWindowConfigurer(Function<Flux<Message<?>>, Flux<Flux<Message<?>>>>)` - a function to apply a transformation into the grouped fluxes for any custom window operation not covered by the exposed options.

Since this component is a `MessageHandler` implementation it can simply be used as a `@Bean` definition together with a `@ServiceActivator` messaging annotation.
With Java DSL it can be used from the `.handle()` EIP-method.
The sample below demonstrates how we can register an `IntegrationFlow` at runtime and how a `FluxAggregatorMessageHandler` can be correlated with a splitter upstream:

====
[source,java]
----
IntegrationFlow fluxFlow =
        (flow) -> flow
                .split()
                .channel(MessageChannels.flux())
                .handle(new FluxAggregatorMessageHandler());

IntegrationFlowContext.IntegrationFlowRegistration registration =
        this.integrationFlowContext.registration(fluxFlow)
                .register();

@SuppressWarnings(""unchecked"")
Flux<Message<?>> window =
        registration.getMessagingTemplate()
                .convertSendAndReceive(new Integer[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, Flux.class);
----
====
",12255,False,2240.409636014142,median
"[[netty-component]]
= Netty Component
//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
:page-source: components/camel-netty/src/main/docs/netty-component.adoc
:docTitle: Netty
:artifactId: camel-netty
:description: Socket level networking using TCP or UDP with the Netty 4.x library.
:since: 2.14
:supportLevel: Stable
:component-header: Both producer and consumer are supported

*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. The value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverClosedChannelException 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. 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. 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 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. 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. 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. 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. The value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverClosedChannelException 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. 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. 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. 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-UsingBasicSSL/TLSconfigurationontheJettyComponent]]
Using Basic SSL/TLS configuration on the Jetty Component

[source,java]
----
Registry registry = context.getRegistry();
registry.bind(""password"", ""changeit"");
registry.bind(""ksf"", new File(""src/test/resources/keystore.jks""));
registry.bind(""tsf"", new File(""src/test/resources/keystore.jks""));

context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?sync=true&ssl=true&passphrase=#password""
         + ""&keyStoreFile=#ksf&trustStoreFile=#tsf"";
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

[[Netty-GettingaccesstoSSLSessionandtheclientcertificate]]
Getting access to SSLSession and the client certificate

You can get access to the `javax.net.ssl.SSLSession` if you eg need to
get details about the client certificate. When `ssl=true` then the
xref:netty-component.adoc[Netty] component will store the `SSLSession` as a
header on the Camel Message as shown below:

[source,java]
----
SSLSession session = exchange.getIn().getHeader(NettyConstants.NETTY_SSL_SESSION, SSLSession.class);
// get the first certificate which is client certificate
javax.security.cert.X509Certificate cert = session.getPeerCertificateChain()[0];
Principal principal = cert.getSubjectDN();
----

Remember to set `needClientAuth=true` to authenticate the client,
otherwise `SSLSession` cannot access information about the client
certificate, and you may get an exception
`javax.net.ssl.SSLPeerUnverifiedException: peer not authenticated`. You
may also get this exception if the client certificate is expired or not
valid etc.

[TIP]
====
The option `sslClientCertHeaders` can be set to `true` which then
enriches the Camel Message with headers having
details about the client certificate. For example the subject name is
readily available in the header `CamelNettySSLClientCertSubjectName`.
====

=== Using Multiple Codecs

In certain cases it may be necessary to add chains of encoders and
decoders to the netty pipeline. To add multpile codecs to a camel netty
endpoint the 'encoders' and 'decoders' uri parameters should be used.
Like the 'encoder' and 'decoder' parameters they are used to supply
references (lists of ChannelUpstreamHandlers and
ChannelDownstreamHandlers) that should be added to the pipeline. Note
that if encoders is specified then the encoder param will be ignored,
similarly for decoders and the decoder param.

[NOTE]
====
Read further above about using non shareable encoders/decoders.
====

The lists of codecs need to be added to the Camel's registry so they can
be resolved when the endpoint is created.

[source,java]
----
ChannelHandlerFactory lengthDecoder = ChannelHandlerFactories.newLengthFieldBasedFrameDecoder(1048576, 0, 4, 0, 4);

StringDecoder stringDecoder = new StringDecoder();
registry.bind(""length-decoder"", lengthDecoder);
registry.bind(""string-decoder"", stringDecoder);

LengthFieldPrepender lengthEncoder = new LengthFieldPrepender(4);
StringEncoder stringEncoder = new StringEncoder();
registry.bind(""length-encoder"", lengthEncoder);
registry.bind(""string-encoder"", stringEncoder);

List<ChannelHandler> decoders = new ArrayList<ChannelHandler>();
decoders.add(lengthDecoder);
decoders.add(stringDecoder);

List<ChannelHandler> encoders = new ArrayList<ChannelHandler>();
encoders.add(lengthEncoder);
encoders.add(stringEncoder);

registry.bind(""encoders"", encoders);
registry.bind(""decoders"", decoders);
----

Spring's native collections support can be used to specify the codec
lists in an application context

[source,xml]
----
<util:list id=""decoders"" list-class=""java.util.LinkedList"">
        <bean class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
            <constructor-arg value=""1048576""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringDecoder""/>
    </util:list>

    <util:list id=""encoders"" list-class=""java.util.LinkedList"">
        <bean class=""io.netty.handler.codec.LengthFieldPrepender"">
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringEncoder""/>
    </util:list>

    <bean id=""length-encoder"" class=""io.netty.handler.codec.LengthFieldPrepender"">
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-encoder"" class=""io.netty.handler.codec.string.StringEncoder""/>

    <bean id=""length-decoder"" class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
        <constructor-arg value=""1048576""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-decoder"" class=""io.netty.handler.codec.string.StringDecoder""/>
----

The bean names can then be used in netty endpoint definitions either as
a comma separated list or contained in a List e.g.

[source,java]
----
 from(""direct:multiple-codec"").to(""netty:tcp://0.0.0.0:{{port}}?encoders=#encoders&sync=false"");

 from(""netty:tcp://0.0.0.0:{{port}}?decoders=#length-decoder,#string-decoder&sync=false"").to(""mock:multiple-codec"");
----

or via XML.

[source,xml]
----
<camelContext id=""multiple-netty-codecs-context"" xmlns=""http://camel.apache.org/schema/spring"">
    <route>
        <from uri=""direct:multiple-codec""/>
        <to uri=""netty:tcp://0.0.0.0:5150?encoders=#encoders&amp;sync=false""/>
    </route>
    <route>
        <from uri=""netty:tcp://0.0.0.0:5150?decoders=#length-decoder,#string-decoder&amp;sync=false""/>
        <to uri=""mock:multiple-codec""/>
    </route>
</camelContext>
----

== Closing Channel When Complete

When acting as a server you sometimes want to close the channel when,
for example, a client conversion is finished. +
 You can do this by simply setting the endpoint option
`disconnect=true`.

However you can also instruct Camel on a per message basis as follows. +
 To instruct Camel to close the channel, you should add a header with
the key `CamelNettyCloseChannelWhenComplete` set to a boolean `true`
value. +
 For instance, the example below will close the channel after it has
written the bye message back to the client:

[source,java]
----
from(""netty:tcp://0.0.0.0:8080"").process(new Processor() {
    public void process(Exchange exchange) throws Exception {
        String body = exchange.getIn().getBody(String.class);
        exchange.getOut().setBody(""Bye "" + body);
        // some condition which determines if we should close
        if (close) {
            exchange.getOut().setHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, true);
        }
    }
});
----

[[Netty-Addingcustomchannelpipelinefactoriestogaincompletecontroloveracreatedpipeline]]
Adding custom channel pipeline factories to gain complete control over a created pipeline

== Custom pipeline

Custom channel pipelines provide complete control to the user over the
handler/interceptor chain by inserting custom handler(s), encoder(s) &
decoder(s) without having to specify them in the Netty Endpoint URL in a
very simple way.

In order to add a custom pipeline, a custom channel pipeline factory
must be created and registered with the context via the context registry
(Registry, or the camel-spring ApplicationContextRegistry etc).

A custom pipeline factory must be constructed as follows

* A Producer linked channel pipeline factory must extend the abstract
class `ClientPipelineFactory`.
* A Consumer linked channel pipeline factory must extend the abstract
class `ServerInitializerFactory`.
* The classes should override the initChannel() method in order to
insert custom handler(s), encoder(s) and decoder(s). Not overriding the
`initChannel()` method creates a pipeline with no handlers, encoders or
decoders wired to the pipeline.

The example below shows how ServerInitializerFactory factory may be
created

=== Using custom pipeline factory

[source,java]
----
public class SampleServerInitializerFactory extends ServerInitializerFactory {
    private int maxLineSize = 1024;

    protected void initChannel(Channel ch) throws Exception {
        ChannelPipeline channelPipeline = ch.pipeline();

        channelPipeline.addLast(""encoder-SD"", new StringEncoder(CharsetUtil.UTF_8));
        channelPipeline.addLast(""decoder-DELIM"", new DelimiterBasedFrameDecoder(maxLineSize, true, Delimiters.lineDelimiter()));
        channelPipeline.addLast(""decoder-SD"", new StringDecoder(CharsetUtil.UTF_8));
        // here we add the default Camel ServerChannelHandler for the consumer, to allow Camel to route the message etc.
        channelPipeline.addLast(""handler"", new ServerChannelHandler(consumer));
    }
}
----

The custom channel pipeline factory can then be added to the registry
and instantiated/utilized on a camel route in the following way

[source,java]
----
Registry registry = camelContext.getRegistry();
ServerInitializerFactory factory = new TestServerInitializerFactory();
registry.bind(""spf"", factory);
context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?serverInitializerFactory=#spf""
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

== Reusing Netty boss and worker thread pools

Netty has two kind of thread pools: boss and worker. By default each
Netty consumer and producer has their private thread pools. If you want
to reuse these thread pools among multiple consumers or producers then
the thread pools must be created and enlisted in the
Registry.

For example using Spring XML we can create a shared worker thread pool
using the `NettyWorkerPoolBuilder` with 2 worker threads as shown below:

[source,xml]
----
<!-- use the worker pool builder to help create the shared thread pool -->
<bean id=""poolBuilder"" class=""org.apache.camel.component.netty.NettyWorkerPoolBuilder"">
  <property name=""workerCount"" value=""2""/>
</bean>

<!-- the shared worker thread pool -->
<bean id=""sharedPool"" class=""org.jboss.netty.channel.socket.nio.WorkerPool""
      factory-bean=""poolBuilder"" factory-method=""build"" destroy-method=""shutdown"">
</bean>
----

[TIP]
====
For boss thread pool there is a
`org.apache.camel.component.netty.NettyServerBossPoolBuilder` builder
for Netty consumers, and a
`org.apache.camel.component.netty.NettyClientBossPoolBuilder` for the
Netty producers.
====

Then in the Camel routes we can refer to this worker pools by
configuring the `workerPool` option in the URI as shown below:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5021?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

And if we have another route we can refer to the shared worker pool:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5022?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

and so forth.

== Multiplexing concurrent messages over a single connection with request/reply

When using Netty for request/reply messaging via the netty producer then by default each
message is sent via a non-shared connection (pooled). This ensures that replies are
automatic being able to map to the correct request thread for further routing in Camel.
In other words correlation between request/reply messages happens out-of-the-box because
the replies comes back on the same connection that was used for sending the request;
and this connection is not shared with others. When the response comes back, the connection
is returned back to the connection pool, where it can be reused by others.

However if you want to multiplex concurrent request/responses on a single shared connection,
then you need to turn off the connection pooling by setting `producerPoolEnabled=false`.
Now this means there is a potential issue with interleaved responses if replies comes back out-of-order.
Therefore you need to have a correlation id in both the request and reply messages so you can properly
correlate the replies to the Camel callback that is responsible for continue processing the message in Camel.
To do this you need to implement `NettyCamelStateCorrelationManager` as correlation manager and configure
it via the `correlationManager=#myManager` option.

[NOTE]
====
We recommend extending the `TimeoutCorrelationManagerSupport` when you build custom correlation managers.
This provides support for timeout and other complexities you otherwise would need to implement as well.
====

You can find an example with the Apache Camel source code in the examples directory
under the `camel-example-netty-custom-correlation` directory.


include::camel-spring-boot::page$netty-starter.adoc[]
",12369,False,2301.097085965814,median
"CLASS zcl_abapgit_git_porcelain DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    TYPES:
      BEGIN OF ty_pull_result,
        files   TYPE zif_abapgit_definitions=>ty_files_tt,
        objects TYPE zif_abapgit_definitions=>ty_objects_tt,
        branch  TYPE zif_abapgit_definitions=>ty_sha1,
      END OF ty_pull_result .
    TYPES:
      BEGIN OF ty_push_result,
        new_files     TYPE zif_abapgit_definitions=>ty_files_tt,
        branch        TYPE zif_abapgit_definitions=>ty_sha1,
        updated_files TYPE zif_abapgit_definitions=>ty_file_signatures_tt,
        new_objects   TYPE zif_abapgit_definitions=>ty_objects_tt,
      END OF ty_push_result .

    CLASS-METHODS pull
      IMPORTING
        !iv_url          TYPE string
        !iv_branch_name  TYPE string
      RETURNING
        VALUE(rs_result) TYPE ty_pull_result
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS push
      IMPORTING
        !is_comment      TYPE zif_abapgit_definitions=>ty_comment
        !io_stage        TYPE REF TO zcl_abapgit_stage
        !it_old_objects  TYPE zif_abapgit_definitions=>ty_objects_tt
        !iv_parent       TYPE zif_abapgit_definitions=>ty_sha1
        !iv_url          TYPE string
        !iv_branch_name  TYPE string
      RETURNING
        VALUE(rs_result) TYPE ty_push_result
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS create_branch
      IMPORTING
        !iv_url  TYPE string
        !iv_name TYPE string
        !iv_from TYPE zif_abapgit_definitions=>ty_sha1
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS create_tag
      IMPORTING
        !iv_url TYPE string
        !is_tag TYPE zif_abapgit_definitions=>ty_git_tag
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS delete_branch
      IMPORTING
        !iv_url    TYPE string
        !is_branch TYPE zif_abapgit_definitions=>ty_git_branch
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS delete_tag
      IMPORTING
        !iv_url TYPE string
        !is_tag TYPE zif_abapgit_definitions=>ty_git_tag
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS full_tree
      IMPORTING
        !it_objects        TYPE zif_abapgit_definitions=>ty_objects_tt
        !iv_branch         TYPE zif_abapgit_definitions=>ty_sha1
      RETURNING
        VALUE(rt_expanded) TYPE zif_abapgit_definitions=>ty_expanded_tt
      RAISING
        zcx_abapgit_exception .
  PRIVATE SECTION.

    TYPES:
      BEGIN OF ty_tree,
        path TYPE string,
        data TYPE xstring,
        sha1 TYPE zif_abapgit_definitions=>ty_sha1,
      END OF ty_tree .
    TYPES:
      ty_trees_tt TYPE STANDARD TABLE OF ty_tree WITH DEFAULT KEY .
    TYPES:
      BEGIN OF ty_folder,
        path  TYPE string,
        count TYPE i,
        sha1  TYPE zif_abapgit_definitions=>ty_sha1,
      END OF ty_folder .
    TYPES:
      ty_folders_tt TYPE STANDARD TABLE OF ty_folder WITH DEFAULT KEY .

    CONSTANTS c_zero TYPE zif_abapgit_definitions=>ty_sha1 VALUE '0000000000000000000000000000000000000000' ##NO_TEXT.

    CLASS-METHODS build_trees
      IMPORTING
        !it_expanded    TYPE zif_abapgit_definitions=>ty_expanded_tt
      RETURNING
        VALUE(rt_trees) TYPE ty_trees_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS find_folders
      IMPORTING
        !it_expanded      TYPE zif_abapgit_definitions=>ty_expanded_tt
      RETURNING
        VALUE(rt_folders) TYPE ty_folders_tt .
    CLASS-METHODS walk
      IMPORTING
        !it_objects TYPE zif_abapgit_definitions=>ty_objects_tt
        !iv_sha1    TYPE zif_abapgit_definitions=>ty_sha1
        !iv_path    TYPE string
      CHANGING
        !ct_files   TYPE zif_abapgit_definitions=>ty_files_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS walk_tree
      IMPORTING
        !it_objects        TYPE zif_abapgit_definitions=>ty_objects_tt
        !iv_tree           TYPE zif_abapgit_definitions=>ty_sha1
        !iv_base           TYPE string
      RETURNING
        VALUE(rt_expanded) TYPE zif_abapgit_definitions=>ty_expanded_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS receive_pack_push
      IMPORTING
        !is_comment     TYPE zif_abapgit_definitions=>ty_comment
        !it_trees       TYPE ty_trees_tt
        !it_blobs       TYPE zif_abapgit_definitions=>ty_files_tt
        !iv_parent      TYPE zif_abapgit_definitions=>ty_sha1
        !iv_parent2     TYPE zif_abapgit_definitions=>ty_sha1 OPTIONAL
        !iv_url         TYPE string
        !iv_branch_name TYPE string
      EXPORTING
        !ev_new_commit  TYPE zif_abapgit_definitions=>ty_sha1
        !et_new_objects TYPE zif_abapgit_definitions=>ty_objects_tt
        !ev_new_tree    TYPE zif_abapgit_definitions=>ty_sha1
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS receive_pack_create_tag
      IMPORTING
        !is_tag TYPE zif_abapgit_definitions=>ty_git_tag
        !iv_url TYPE string
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS create_annotated_tag
      IMPORTING
        !is_tag TYPE zif_abapgit_definitions=>ty_git_tag
        !iv_url TYPE string
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS create_lightweight_tag
      IMPORTING
        !is_tag TYPE zif_abapgit_definitions=>ty_git_tag
        !iv_url TYPE string
      RAISING
        zcx_abapgit_exception .
ENDCLASS.



CLASS ZCL_ABAPGIT_GIT_PORCELAIN IMPLEMENTATION.


  METHOD build_trees.

    DATA: lt_nodes   TYPE zcl_abapgit_git_pack=>ty_nodes_tt,
          ls_tree    LIKE LINE OF rt_trees,
          lv_len     TYPE i,
          lt_folders TYPE ty_folders_tt.

    FIELD-SYMBOLS: <ls_folder> LIKE LINE OF lt_folders,
                   <ls_node>   LIKE LINE OF lt_nodes,
                   <ls_sub>    LIKE LINE OF lt_folders,
                   <ls_exp>    LIKE LINE OF it_expanded.


    lt_folders = find_folders( it_expanded ).

* start with the deepest folders
    SORT lt_folders BY count DESCENDING.

    LOOP AT lt_folders ASSIGNING <ls_folder>.
      CLEAR lt_nodes.

* files
      LOOP AT it_expanded ASSIGNING <ls_exp> WHERE path = <ls_folder>-path.
        APPEND INITIAL LINE TO lt_nodes ASSIGNING <ls_node>.
        <ls_node>-chmod = <ls_exp>-chmod.
        <ls_node>-name  = <ls_exp>-name.
        <ls_node>-sha1  = <ls_exp>-sha1.
      ENDLOOP.

* folders
      LOOP AT lt_folders ASSIGNING <ls_sub> WHERE count = <ls_folder>-count + 1.
        lv_len = strlen( <ls_folder>-path ).
        IF strlen( <ls_sub>-path ) > lv_len AND <ls_sub>-path(lv_len) = <ls_folder>-path.
          APPEND INITIAL LINE TO lt_nodes ASSIGNING <ls_node>.
          <ls_node>-chmod = zif_abapgit_definitions=>gc_chmod-dir.

* extract folder name, this can probably be done easier using regular expressions
          <ls_node>-name = <ls_sub>-path+lv_len.
          lv_len = strlen( <ls_node>-name ) - 1.
          <ls_node>-name = <ls_node>-name(lv_len).

          <ls_node>-sha1 = <ls_sub>-sha1.
        ENDIF.
      ENDLOOP.

      CLEAR ls_tree.
      ls_tree-path = <ls_folder>-path.
      ls_tree-data = zcl_abapgit_git_pack=>encode_tree( lt_nodes ).
      ls_tree-sha1 = zcl_abapgit_hash=>sha1( iv_type = zif_abapgit_definitions=>gc_type-tree iv_data = ls_tree-data ).
      APPEND ls_tree TO rt_trees.

      <ls_folder>-sha1 = ls_tree-sha1.
    ENDLOOP.

  ENDMETHOD.


  METHOD create_annotated_tag.

    receive_pack_create_tag(
      is_tag = is_tag
      iv_url = iv_url ).

  ENDMETHOD.


  METHOD create_branch.

    DATA: lt_objects TYPE zif_abapgit_definitions=>ty_objects_tt,
          lv_pack    TYPE xstring.

    IF iv_name CS ` `.
      zcx_abapgit_exception=>raise( 'Branch name cannot contain blank spaces' ).
    ENDIF.

* ""client MUST send an empty packfile""
* https://github.com/git/git/blob/master/Documentation/technical/pack-protocol.txt#L514
    lv_pack = zcl_abapgit_git_pack=>encode( lt_objects ).

    zcl_abapgit_git_transport=>receive_pack(
      iv_url         = iv_url
      iv_old         = c_zero
      iv_new         = iv_from
      iv_branch_name = iv_name
      iv_pack        = lv_pack ).

  ENDMETHOD.


  METHOD create_lightweight_tag.

    DATA: lt_objects TYPE zif_abapgit_definitions=>ty_objects_tt,
          lv_pack    TYPE xstring.

* ""client MUST send an empty packfile""
* https://github.com/git/git/blob/master/Documentation/technical/pack-protocol.txt#L514
    lv_pack = zcl_abapgit_git_pack=>encode( lt_objects ).

    zcl_abapgit_git_transport=>receive_pack(
      iv_url         = iv_url
      iv_old         = c_zero
      iv_new         = is_tag-sha1
      iv_branch_name = is_tag-name
      iv_pack        = lv_pack ).

  ENDMETHOD.


  METHOD create_tag.

    IF is_tag-name CS ` `.
      zcx_abapgit_exception=>raise( 'Tag name cannot contain blank spaces' ).
    ENDIF.

    CASE is_tag-type.
      WHEN zif_abapgit_definitions=>c_git_branch_type-annotated_tag.

        create_annotated_tag(
          is_tag = is_tag
          iv_url = iv_url ).

      WHEN zif_abapgit_definitions=>c_git_branch_type-lightweight_tag.

        create_lightweight_tag(
          is_tag = is_tag
          iv_url = iv_url ).

      WHEN OTHERS.

        zcx_abapgit_exception=>raise( |Invalid tag type: { is_tag-type }| ).

    ENDCASE.

  ENDMETHOD.


  METHOD delete_branch.

    DATA: lt_objects TYPE zif_abapgit_definitions=>ty_objects_tt,
          lv_pack    TYPE xstring.


* ""client MUST send an empty packfile""
* https://github.com/git/git/blob/master/Documentation/technical/pack-protocol.txt#L514
    lv_pack = zcl_abapgit_git_pack=>encode( lt_objects ).

    zcl_abapgit_git_transport=>receive_pack(
      iv_url         = iv_url
      iv_old         = is_branch-sha1
      iv_new         = c_zero
      iv_branch_name = is_branch-name
      iv_pack        = lv_pack ).

  ENDMETHOD.


  METHOD delete_tag.

    DATA: lt_objects TYPE zif_abapgit_definitions=>ty_objects_tt,
          lv_pack    TYPE xstring.


* ""client MUST send an empty packfile""
* https://github.com/git/git/blob/master/Documentation/technical/pack-protocol.txt#L514
    lv_pack = zcl_abapgit_git_pack=>encode( lt_objects ).

    zcl_abapgit_git_transport=>receive_pack(
      iv_url         = iv_url
      iv_old         = is_tag-sha1
      iv_new         = c_zero
      iv_branch_name = is_tag-name
      iv_pack        = lv_pack ).

  ENDMETHOD.


  METHOD find_folders.

    DATA: lt_paths TYPE TABLE OF string,
          lv_split TYPE string,
          lv_path  TYPE string.

    FIELD-SYMBOLS: <ls_folder> LIKE LINE OF rt_folders,
                   <ls_new>    LIKE LINE OF rt_folders,
                   <ls_exp>    LIKE LINE OF it_expanded.


    LOOP AT it_expanded ASSIGNING <ls_exp>.
      READ TABLE rt_folders WITH KEY path = <ls_exp>-path TRANSPORTING NO FIELDS.
      IF sy-subrc <> 0.
        APPEND INITIAL LINE TO rt_folders ASSIGNING <ls_folder>.
        <ls_folder>-path = <ls_exp>-path.
      ENDIF.
    ENDLOOP.

* add empty folders
    LOOP AT rt_folders ASSIGNING <ls_folder>.
      SPLIT <ls_folder>-path AT '/' INTO TABLE lt_paths.

      CLEAR lv_path.
      LOOP AT lt_paths INTO lv_split.
        CONCATENATE lv_path lv_split '/' INTO lv_path.
        READ TABLE rt_folders WITH KEY path = lv_path TRANSPORTING NO FIELDS.
        IF sy-subrc <> 0.
          APPEND INITIAL LINE TO rt_folders ASSIGNING <ls_new>.
          <ls_new>-path = lv_path.
        ENDIF.
      ENDLOOP.
    ENDLOOP.

    LOOP AT rt_folders ASSIGNING <ls_folder>.
      FIND ALL OCCURRENCES OF '/' IN <ls_folder>-path MATCH COUNT <ls_folder>-count.
    ENDLOOP.

  ENDMETHOD.


  METHOD full_tree.

    DATA: ls_object LIKE LINE OF it_objects,
          ls_commit TYPE zcl_abapgit_git_pack=>ty_commit.


    READ TABLE it_objects INTO ls_object
      WITH KEY type COMPONENTS
        type = zif_abapgit_definitions=>gc_type-commit
        sha1 = iv_branch .
    IF sy-subrc <> 0.
      zcx_abapgit_exception=>raise( 'commit not found' ).
    ENDIF.
    ls_commit = zcl_abapgit_git_pack=>decode_commit( ls_object-data ).

    rt_expanded = walk_tree( it_objects = it_objects
                             iv_tree    = ls_commit-tree
                             iv_base    = '/' ).

  ENDMETHOD.


  METHOD pull.

    DATA: ls_object LIKE LINE OF rs_result-objects,
          ls_commit TYPE zcl_abapgit_git_pack=>ty_commit.


    zcl_abapgit_git_transport=>upload_pack(
      EXPORTING
        iv_url         = iv_url
        iv_branch_name = iv_branch_name
      IMPORTING
        et_objects     = rs_result-objects
        ev_branch      = rs_result-branch ).

    READ TABLE rs_result-objects INTO ls_object
      WITH KEY type COMPONENTS
        type = zif_abapgit_definitions=>gc_type-commit
        sha1 = rs_result-branch.
    IF sy-subrc <> 0.
      zcx_abapgit_exception=>raise( 'Commit/branch not found' ).
    ENDIF.
    ls_commit = zcl_abapgit_git_pack=>decode_commit( ls_object-data ).

    walk( EXPORTING it_objects = rs_result-objects
                    iv_sha1 = ls_commit-tree
                    iv_path = '/'
          CHANGING ct_files = rs_result-files ).

  ENDMETHOD.


  METHOD push.

    DATA: lt_expanded TYPE zif_abapgit_definitions=>ty_expanded_tt,
          lt_blobs    TYPE zif_abapgit_definitions=>ty_files_tt,
          lv_sha1     TYPE zif_abapgit_definitions=>ty_sha1,
          lv_new_tree TYPE zif_abapgit_definitions=>ty_sha1,
          lt_trees    TYPE ty_trees_tt,
          lt_stage    TYPE zcl_abapgit_stage=>ty_stage_tt.

    FIELD-SYMBOLS: <ls_stage>   LIKE LINE OF lt_stage,
                   <ls_updated> LIKE LINE OF rs_result-updated_files,
                   <ls_exp>     LIKE LINE OF lt_expanded.


    lt_expanded = full_tree( it_objects = it_old_objects
                             iv_branch  = iv_parent ).

    lt_stage = io_stage->get_all( ).
    LOOP AT lt_stage ASSIGNING <ls_stage>.

      "" Save file ref to updated files table
      APPEND INITIAL LINE TO rs_result-updated_files ASSIGNING <ls_updated>.
      MOVE-CORRESPONDING <ls_stage>-file TO <ls_updated>.

      CASE <ls_stage>-method.
        WHEN zcl_abapgit_stage=>c_method-add.

          APPEND <ls_stage>-file TO lt_blobs.

          READ TABLE lt_expanded ASSIGNING <ls_exp> WITH KEY
            name = <ls_stage>-file-filename
            path = <ls_stage>-file-path.
          IF sy-subrc <> 0. "" new files
            APPEND INITIAL LINE TO lt_expanded ASSIGNING <ls_exp>.
            <ls_exp>-name  = <ls_stage>-file-filename.
            <ls_exp>-path  = <ls_stage>-file-path.
            <ls_exp>-chmod = zif_abapgit_definitions=>gc_chmod-file.
          ENDIF.

          lv_sha1 = zcl_abapgit_hash=>sha1( iv_type = zif_abapgit_definitions=>gc_type-blob
                                            iv_data = <ls_stage>-file-data ).
          IF <ls_exp>-sha1 <> lv_sha1.
            <ls_exp>-sha1 = lv_sha1.
          ENDIF.

          <ls_updated>-sha1 = lv_sha1.   ""New sha1

        WHEN zcl_abapgit_stage=>c_method-rm.
          DELETE lt_expanded
            WHERE name = <ls_stage>-file-filename
            AND   path = <ls_stage>-file-path.
          ASSERT sy-subrc = 0.

          CLEAR <ls_updated>-sha1.       "" Mark as deleted

        WHEN OTHERS.
          zcx_abapgit_exception=>raise( 'stage method not supported, todo' ).
      ENDCASE.
    ENDLOOP.

    lt_trees = build_trees( lt_expanded ).

    receive_pack_push(
      EXPORTING
        is_comment     = is_comment
        it_trees       = lt_trees
        iv_branch_name = iv_branch_name
        iv_url         = iv_url
        iv_parent      = iv_parent
        iv_parent2     = io_stage->get_merge_source( )
        it_blobs       = lt_blobs
      IMPORTING
        ev_new_commit  = rs_result-branch
        et_new_objects = rs_result-new_objects
        ev_new_tree    = lv_new_tree ).

    APPEND LINES OF it_old_objects TO rs_result-new_objects.
    walk( EXPORTING it_objects = rs_result-new_objects
                    iv_sha1 = lv_new_tree
                    iv_path = '/'
          CHANGING ct_files = rs_result-new_files ).

  ENDMETHOD.


  METHOD receive_pack_create_tag.

    DATA: lv_tag          TYPE xstring,
          lt_objects      TYPE zif_abapgit_definitions=>ty_objects_tt,
          lv_pack         TYPE xstring,
          ls_object       LIKE LINE OF lt_objects,
          ls_tag          TYPE zcl_abapgit_git_pack=>ty_tag,
          lv_new_tag_sha1 TYPE zif_abapgit_definitions=>ty_sha1.

* new tag
    ls_tag-object       = is_tag-sha1.
    ls_tag-type         = zif_abapgit_definitions=>gc_type-commit.
    ls_tag-tag          = is_tag-name.
    ls_tag-tagger_name  = is_tag-tagger_name.
    ls_tag-tagger_email = is_tag-tagger_email.
    ls_tag-message      = is_tag-message
                      && |{ zif_abapgit_definitions=>gc_newline }|
                      && |{ zif_abapgit_definitions=>gc_newline }|
                      && is_tag-body.

    lv_tag = zcl_abapgit_git_pack=>encode_tag( ls_tag ).

    lv_new_tag_sha1 = zcl_abapgit_hash=>sha1(
      iv_type = zif_abapgit_definitions=>gc_type-tag
      iv_data = lv_tag ).

    CLEAR ls_object.
    ls_object-sha1 = lv_new_tag_sha1.
    ls_object-type = zif_abapgit_definitions=>gc_type-tag.
    ls_object-data = lv_tag.
    ls_object-index = 1.
    APPEND ls_object TO lt_objects.

    lv_pack = zcl_abapgit_git_pack=>encode( lt_objects ).

    zcl_abapgit_git_transport=>receive_pack(
      iv_url         = iv_url
      iv_old         = c_zero
      iv_new         = lv_new_tag_sha1
      iv_branch_name = is_tag-name
      iv_pack        = lv_pack ).

  ENDMETHOD.


  METHOD receive_pack_push.

    DATA: lv_time   TYPE zcl_abapgit_time=>ty_unixtime,
          lv_commit TYPE xstring,
          lv_pack   TYPE xstring,
          ls_object LIKE LINE OF et_new_objects,
          ls_commit TYPE zcl_abapgit_git_pack=>ty_commit.
    DATA: uindex     TYPE sy-index.

    FIELD-SYMBOLS: <ls_tree> LIKE LINE OF it_trees,
                   <ls_blob> LIKE LINE OF it_blobs.


    lv_time = zcl_abapgit_time=>get( ).

    READ TABLE it_trees ASSIGNING <ls_tree> WITH KEY path = '/'.
    ASSERT sy-subrc = 0.

* new commit
    ls_commit-committer = |{ is_comment-committer-name
      } <{ is_comment-committer-email }> { lv_time }|.
    IF is_comment-author-name IS NOT INITIAL.
      ls_commit-author = |{ is_comment-author-name
        } <{ is_comment-author-email }> { lv_time }|.
    ELSE.
      ls_commit-author = ls_commit-committer.
    ENDIF.

    ls_commit-tree      = <ls_tree>-sha1.
    ls_commit-parent    = iv_parent.
    ls_commit-parent2   = iv_parent2.
    ls_commit-body      = is_comment-comment.
    lv_commit = zcl_abapgit_git_pack=>encode_commit( ls_commit ).

    CLEAR ls_object.
    ls_object-sha1 = zcl_abapgit_hash=>sha1( iv_type = zif_abapgit_definitions=>gc_type-commit iv_data = lv_commit ).
    ls_object-type = zif_abapgit_definitions=>gc_type-commit.
    ls_object-data = lv_commit.
    APPEND ls_object TO et_new_objects.

    LOOP AT it_trees ASSIGNING <ls_tree>.
      CLEAR ls_object.
      ls_object-sha1 = <ls_tree>-sha1.

      READ TABLE et_new_objects
        WITH KEY type COMPONENTS
          type = zif_abapgit_definitions=>gc_type-tree
          sha1 = ls_object-sha1
        TRANSPORTING NO FIELDS.
      IF sy-subrc = 0.
* two identical trees added at the same time, only add one to the pack
        CONTINUE.
      ENDIF.

      ls_object-type = zif_abapgit_definitions=>gc_type-tree.
      ls_object-data = <ls_tree>-data.
      uindex = uindex + 1.
      ls_object-index = uindex.
      APPEND ls_object TO et_new_objects.
    ENDLOOP.

    LOOP AT it_blobs ASSIGNING <ls_blob>.
      CLEAR ls_object.
      ls_object-sha1 = zcl_abapgit_hash=>sha1(
        iv_type = zif_abapgit_definitions=>gc_type-blob
        iv_data = <ls_blob>-data ).

      READ TABLE et_new_objects
        WITH KEY type COMPONENTS
          type = zif_abapgit_definitions=>gc_type-blob
          sha1 = ls_object-sha1
        TRANSPORTING NO FIELDS.
      IF sy-subrc = 0.
* two identical files added at the same time, only add one blob to the pack
        CONTINUE.
      ENDIF.

      ls_object-type = zif_abapgit_definitions=>gc_type-blob.
      ASSERT NOT <ls_blob>-data IS INITIAL.
      ls_object-data = <ls_blob>-data.
      uindex = uindex + 1.
      ls_object-index = uindex.
      APPEND ls_object TO et_new_objects.
    ENDLOOP.

    lv_pack = zcl_abapgit_git_pack=>encode( et_new_objects ).

    ev_new_commit = zcl_abapgit_hash=>sha1(
      iv_type = zif_abapgit_definitions=>gc_type-commit
      iv_data = lv_commit ).

    zcl_abapgit_git_transport=>receive_pack(
      iv_url         = iv_url
      iv_old         = iv_parent
      iv_new         = ev_new_commit
      iv_branch_name = iv_branch_name
      iv_pack        = lv_pack ).

    ev_new_tree = ls_commit-tree.

  ENDMETHOD.


  METHOD walk.

    DATA: lv_path  TYPE string,
          ls_file  LIKE LINE OF ct_files,
          lt_nodes TYPE zcl_abapgit_git_pack=>ty_nodes_tt.

    FIELD-SYMBOLS: <ls_tree> LIKE LINE OF it_objects,
                   <ls_blob> LIKE LINE OF it_objects,
                   <ls_node> LIKE LINE OF lt_nodes.


    READ TABLE it_objects ASSIGNING <ls_tree>
      WITH KEY type COMPONENTS
        type = zif_abapgit_definitions=>gc_type-tree
        sha1 = iv_sha1.
    IF sy-subrc <> 0.
      zcx_abapgit_exception=>raise( 'Walk, tree not found' ).
    ENDIF.

    lt_nodes = zcl_abapgit_git_pack=>decode_tree( <ls_tree>-data ).

    LOOP AT lt_nodes ASSIGNING <ls_node>.
      IF <ls_node>-chmod = zif_abapgit_definitions=>gc_chmod-file.
        READ TABLE it_objects ASSIGNING <ls_blob>
          WITH KEY type COMPONENTS
            type = zif_abapgit_definitions=>gc_type-blob
            sha1 = <ls_node>-sha1.
        IF sy-subrc <> 0.
          zcx_abapgit_exception=>raise( 'Walk, blob not found' ).
        ENDIF.

        CLEAR ls_file.
        ls_file-path     = iv_path.
        ls_file-filename = <ls_node>-name.
        ls_file-data     = <ls_blob>-data.
        ls_file-sha1     = <ls_blob>-sha1.
        APPEND ls_file TO ct_files.
      ENDIF.
    ENDLOOP.

    LOOP AT lt_nodes ASSIGNING <ls_node> WHERE chmod = zif_abapgit_definitions=>gc_chmod-dir.
      CONCATENATE iv_path <ls_node>-name '/' INTO lv_path.
      walk( EXPORTING it_objects = it_objects
                      iv_sha1 = <ls_node>-sha1
                      iv_path = lv_path
            CHANGING ct_files = ct_files ).
    ENDLOOP.

  ENDMETHOD.


  METHOD walk_tree.

    DATA: ls_object   LIKE LINE OF it_objects,
          lt_expanded LIKE rt_expanded,
          lt_nodes    TYPE zcl_abapgit_git_pack=>ty_nodes_tt.

    FIELD-SYMBOLS: <ls_exp>  LIKE LINE OF rt_expanded,
                   <ls_node> LIKE LINE OF lt_nodes.


    READ TABLE it_objects INTO ls_object
      WITH KEY type COMPONENTS
        type = zif_abapgit_definitions=>gc_type-tree
        sha1 = iv_tree.
    IF sy-subrc <> 0.
      zcx_abapgit_exception=>raise( 'tree not found' ).
    ENDIF.
    lt_nodes = zcl_abapgit_git_pack=>decode_tree( ls_object-data ).

    LOOP AT lt_nodes ASSIGNING <ls_node>.
      CASE <ls_node>-chmod.
        WHEN zif_abapgit_definitions=>gc_chmod-file
            OR zif_abapgit_definitions=>gc_chmod-executable.
          APPEND INITIAL LINE TO rt_expanded ASSIGNING <ls_exp>.
          <ls_exp>-path  = iv_base.
          <ls_exp>-name  = <ls_node>-name.
          <ls_exp>-sha1  = <ls_node>-sha1.
          <ls_exp>-chmod = <ls_node>-chmod.
        WHEN zif_abapgit_definitions=>gc_chmod-dir.
          lt_expanded = walk_tree(
            it_objects = it_objects
            iv_tree    = <ls_node>-sha1
            iv_base    = iv_base && <ls_node>-name && '/' ).
          APPEND LINES OF lt_expanded TO rt_expanded.
        WHEN OTHERS.
          zcx_abapgit_exception=>raise( 'walk_tree: unknown chmod' ).
      ENDCASE.
    ENDLOOP.

  ENDMETHOD.
ENDCLASS.
",6245,False,1307.7787345106387,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.

    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
      RAISING
        zcx_excel .
    METHODS get_option
      RETURNING
        VALUE(rs_option) TYPE zexcel_s_converter_option .
    METHODS open_file
      RAISING
        zcx_excel .
    METHODS set_option
      IMPORTING
        !is_option TYPE zexcel_s_converter_option .
    METHODS write_file
      IMPORTING
        !i_path TYPE string OPTIONAL
      RAISING
        zcx_excel .
*""* 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.
    CLASS-METHODS get_subclasses
      IMPORTING
        is_clskey  TYPE seoclskey
      CHANGING
        ct_classes TYPE seor_implementing_keys.

    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 n LENGTH 3 .
    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 c VALUE 'H'.                  ""#EC NOTEXT
    CONSTANTS c_type_str TYPE c VALUE 'P'.                  ""#EC NOTEXT
    CONSTANTS c_type_nor TYPE c VALUE 'N'.                  ""#EC NOTEXT
    CONSTANTS c_type_sub TYPE c VALUE 'S'.                  ""#EC NOTEXT
    CONSTANTS c_type_tot TYPE c 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 .
    CLASS-METHODS get_alv_converters.
    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 abap_typekind 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 abap_typekind 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 abap_typekind 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 abap_typekind 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 ty_style_type
        !i_alignment   TYPE zexcel_alignment DEFAULT space
        !i_inttype     TYPE abap_typekind 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 abap_typekind
        !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.
    ELSEIF 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.
  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,
          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.

    get_alv_converters( ).

    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 tabfdpos.

    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->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.
      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.

    l_string = i_value.

    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 ) .
      ELSEIF wt_filter IS NOT INITIAL.
* Let's check for filter.
        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.

* 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.
            CLEAR ls_types-clsname.
            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 ls_types-clsname IS NOT INITIAL.
        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.
      CLEAR wt_fieldcatalog.
      GET REFERENCE OF it_table INTO wo_table.
    ENDIF.
  ENDMETHOD.


  METHOD get_alv_converters.
    DATA:
      lt_direct_implementations TYPE seor_implementing_keys,
      lt_all_implementations    TYPE seor_implementing_keys,
      ls_impkey                 TYPE seor_implementing_key,
      ls_classkey               TYPE seoclskey,
      lr_implementation         TYPE REF TO zif_excel_converter,
      ls_object                 TYPE ts_alv_types,
      lr_classdescr             TYPE REF TO cl_abap_classdescr.

    ls_classkey-clsname = 'ZIF_EXCEL_CONVERTER'.

    CALL FUNCTION 'SEO_INTERFACE_IMPLEM_GET_ALL'
      EXPORTING
        intkey  = ls_classkey
      IMPORTING
        impkeys = lt_direct_implementations
      EXCEPTIONS
        OTHERS  = 2.

    CHECK sy-subrc = 0.

    LOOP AT lt_direct_implementations INTO ls_impkey.
      lr_classdescr ?= cl_abap_classdescr=>describe_by_name( ls_impkey-clsname ).
      IF lr_classdescr->is_instantiatable( ) = abap_true.
        APPEND ls_impkey TO lt_all_implementations.
      ENDIF.

      ls_classkey-clsname = ls_impkey-clsname.
      get_subclasses( EXPORTING is_clskey = ls_classkey CHANGING ct_classes = lt_all_implementations ).
    ENDLOOP.

    SORT lt_all_implementations BY clsname.
    DELETE ADJACENT DUPLICATES FROM lt_all_implementations COMPARING clsname.

    LOOP AT lt_all_implementations INTO ls_impkey.
      CLEAR ls_object.
      CREATE OBJECT lr_implementation TYPE (ls_impkey-clsname).
      ls_object-seoclass = lr_implementation->get_supported_class( ).

      IF ls_object-seoclass IS NOT INITIAL.
        ls_object-clsname  = ls_impkey-clsname.
        INSERT ls_object INTO TABLE wt_objects.
      ENDIF.
    ENDLOOP.
  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 get_subclasses.
    DATA:
      lt_subclasses TYPE seor_inheritance_keys,
      ls_subclass   TYPE seor_inheritance_key,
      lr_classdescr TYPE REF TO cl_abap_classdescr.

    CALL FUNCTION 'SEO_CLASS_GET_ALL_SUBS'
      EXPORTING
        clskey             = is_clskey
      IMPORTING
        inhkeys            = lt_subclasses
      EXCEPTIONS
        class_not_existing = 1
        OTHERS             = 2.

    CHECK sy-subrc = 0.

    LOOP AT lt_subclasses INTO ls_subclass.
      lr_classdescr ?= cl_abap_classdescr=>describe_by_name( ls_subclass-clsname ).
      IF lr_classdescr->is_instantiatable( ) = abap_true.
        APPEND ls_subclass TO ct_classes.
      ENDIF.
    ENDLOOP.
  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,
          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
                                  ip_conv_exit_length = ws_option-conv_exit_length ).
          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
                                  ip_conv_exit_length = ws_option-conv_exit_length  ).
          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> .

    CLEAR: 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
                                  ip_conv_exit_length = ws_option-conv_exit_length ).
          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
                                  ip_conv_exit_length = ws_option-conv_exit_length   ).
          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>.

    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
        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 OR
           cl_abap_typedescr=>typekind_decfloat OR
           cl_abap_typedescr=>typekind_decfloat16 OR
           cl_abap_typedescr=>typekind_decfloat34.
        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>.

    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.
",15862,True,3302.4679371656384,median
"[[cluster-nodes-stats]]
=== Nodes stats API
++++
<titleabbrev>Nodes stats</titleabbrev>
++++

Returns cluster nodes statistics.

[[cluster-nodes-stats-api-request]]
==== {api-request-title}

`GET /_nodes/stats` +

`GET /_nodes/<node_id>/stats` +

`GET/_nodes/stats/<metric>` +

`GET/_nodes/<node_id>/stats/<metric>` +

`GET /_nodes/stats/<metric>/<index_metric>` +

`GET /_nodes/<node_id>/stats/<metric>/<index_metric>`


[[cluster-nodes-stats-api-desc]]
==== {api-description-title}

You can use the cluster nodes stats API to retrieve statistics for nodes in a cluster.


All the nodes selective options are explained <<cluster-nodes,here>>.

By default, all stats are returned. You can limit the returned information by
using metrics.

[[cluster-nodes-stats-api-path-params]]
==== {api-path-parms-title}


`<metric>`::
    (Optional, string) Limits the information returned to the specific metrics.
    A comma-separated list of the following options:
+
--
  `adaptive_selection`::
      Statistics about <<search-adaptive-replica,adaptive replica selection>>.

  `breaker`::
      Statistics about the field data circuit breaker.

  `discovery`::
      Statistics about the discovery.

  `fs`::
      File system information, data path, free disk space, read/write
      stats.

  `http`::
      HTTP connection information.

  `indexing_pressure`::
        Statistics about the node's indexing load and related rejections.

  `indices`::
      Indices stats about size, document count, indexing and deletion times,
      search times, field cache size, merges and flushes.

  `ingest`::
      Statistics about ingest preprocessing.

  `jvm`::
      JVM stats, memory pool information, garbage collection, buffer
      pools, number of loaded/unloaded classes.

  `os`::
      Operating system stats, load average, mem, swap.

  `process`::
      Process statistics, memory consumption, cpu usage, open
      file descriptors.

  `thread_pool`::
      Statistics about each thread pool, including current size, queue and
      rejected tasks.

  `transport`::
      Transport statistics about sent and received bytes in cluster
      communication.
--

`<index_metric>`::
    (Optional, string) Limit the information returned for `indices` metric to
    the specific index metrics. It can be used only if `indices` (or `all`)
    metric is specified. Supported metrics are:
+
--
    * `completion`
    * `docs`
    * `fielddata`
    * `flush`
    * `get`
    * `indexing`
    * `merge`
    * `query_cache`
    * `recovery`
    * `refresh`
    * `request_cache`
    * `search`
    * `segments`
    * `store`
    * `translog`
    * `warmer`
--

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=node-id]


[[cluster-nodes-stats-api-query-params]]
==== {api-query-parms-title}

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=completion-fields]

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=fielddata-fields]

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=fields]

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=groups]

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=level]

`types`::
    (Optional, string) A comma-separated list of document types for the
    `indexing` index metric.

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=timeoutparms]

include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=include-segment-file-sizes]

[role=""child_attributes""]
[[cluster-nodes-stats-api-response-body]]
==== {api-response-body-title}

`_nodes`::
(object)
Contains statistics about the number of nodes selected by the request.
+
.Properties of `_nodes`
[%collapsible%open]
====
`total`::
(integer)
Total number of nodes selected by the request.

`successful`::
(integer)
Number of nodes that responded successfully to the request.

`failed`::
(integer)
Number of nodes that rejected the request or failed to respond. If this value
is not `0`, a reason for the rejection or failure is included in the response.
====

`cluster_name`::
(string)
Name of the cluster. Based on the <<cluster.name>> setting.

`nodes`::
(object)
Contains statistics for the nodes selected by the request.
+
.Properties of `nodes`
[%collapsible%open]
====
`<node_id>`::
(object)
Contains statistics for the node.
+
.Properties of `<node_id>`
[%collapsible%open]
=====
`timestamp`::
(integer)
Time the node stats were collected for this response. Recorded in milliseconds
since the {wikipedia}/Unix_time[Unix Epoch].

`name`::
(string)
Human-readable identifier for the node. Based on the <<node.name>> setting.

`transport_address`::
(string)
Host and port for the <<modules-transport,transport layer>>, used for internal
communication between nodes in a cluster.

`host`::
(string)
Network host for the node, based on the <<network.host>> setting.

`ip`::
(string)
IP address and port for the node.

`roles`::
(array of strings)
Roles assigned to the node. See <<modules-node>>.

`attributes`::
(object)
Contains a list of attributes for the node.

[[cluster-nodes-stats-api-response-body-indices]]
`indices`::
(object)
Contains statistics about indices with shards assigned to the node.
+
.Properties of `indices`
[%collapsible%open]
======
`docs`::
(object)
Contains statistics about documents across all primary shards assigned to the
node.
+
.Properties of `docs`
[%collapsible%open]
=======
`count`::
(integer)
include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=docs-count]

`deleted`::
(integer)
include::{es-repo-dir}/rest-api/common-parms.asciidoc[tag=docs-deleted]
=======

`store`::
(object)
Contains statistics about the size of shards assigned to the node.
+
.Properties of `store`
[%collapsible%open]
=======
`size`::
(<<byte-units,byte value>>)
Total size of all shards assigned to the node.

`size_in_bytes`::
(integer)
Total size, in bytes, of all shards assigned to the node.

`reserved`::
(<<byte-units,byte value>>)
A prediction of how much larger the shard stores on this node will eventually
grow due to ongoing peer recoveries, restoring snapshots, and similar
activities. A value of `-1b` indicates that this is not available.

`reserved_in_bytes`::
(integer)
A prediction, in bytes, of how much larger the shard stores on this node will
eventually grow due to ongoing peer recoveries, restoring snapshots, and
similar activities. A value of `-1` indicates that this is not available.
=======

`indexing`::
(object)
Contains statistics about indexing operations for the node.
+
.Properties of `indexing`
[%collapsible%open]
=======
`index_total`::
(integer)
Total number of indexing operations.

`index_time`::
(<<time-units,time value>>)
Total time spent performing indexing operations.

`index_time_in_millis`::
(integer)
Total time in milliseconds
spent performing indexing operations.

`index_current`::
(integer)
Number of indexing operations currently running.

`index_failed`::
(integer)
Number of failed indexing operations.

`delete_total`::
(integer)
Total number of deletion operations.

`delete_time`::
(<<time-units,time value>>)
Time spent performing deletion operations.

`delete_time_in_millis`::
(integer)
Time in milliseconds
spent performing deletion operations.

`delete_current`::
(integer)
Number of deletion operations currently running.

`noop_update_total`::
(integer)
Total number of noop operations.

`is_throttled`::
(boolean)
Number of times
operations were throttled.

`throttle_time`::
(<<time-units,time value>>)
Total time spent throttling operations.

`throttle_time_in_millis`::
(integer)
Total time in milliseconds
spent throttling operations.
=======

`get`::
(object)
Contains statistics about get operations for the node.
+
.Properties of `get`
[%collapsible%open]
=======
`total`::
(integer)
Total number of get operations.

`getTime`::
(<<time-units,time value>>)
Time spent performing get operations.

`time_in_millis`::
(integer)
Time in milliseconds
spent performing get operations.

`exists_total`::
(integer)
Total number of successful get operations.

`exists_time`::
(<<time-units,time value>>)
Time spent performing successful get operations.

`exists_time_in_millis`::
(integer)
Time in milliseconds
spent performing successful get operations.

`missing_total`::
(integer)
Total number of failed get operations.

`missing_time`::
(<<time-units,time value>>)
Time spent performing failed get operations.

`missing_time_in_millis`::
(integer)
Time in milliseconds
spent performing failed get operations.

`current`::
(integer)
Number of get operations currently running.
=======

`search`::
(object)
Contains statistics about search operations for the node.
+
.Properties of `search`
[%collapsible%open]
=======
`open_contexts`::
(integer)
Number of open search contexts.

`query_total`::
(integer)
Total number of query operations.

`query_time`::
(<<time-units,time value>>)
Time spent performing query operations.

`query_time_in_millis`::
(integer)
Time in milliseconds
spent performing query operations.

`query_current`::
(integer)
Number of query operations currently running.

`fetch_total`::
(integer)
Total number of fetch operations.

`fetch_time`::
(<<time-units,time value>>)
Time spent performing fetch operations.

`fetch_time_in_millis`::
(integer)
Time in milliseconds
spent performing fetch operations.

`fetch_current`::
(integer)
Number of fetch operations currently running.

`scroll_total`::
(integer)
Total number of scroll operations.

`scroll_time`::
(<<time-units,time value>>)
Time spent performing scroll operations.

`scroll_time_in_millis`::
(integer)
Time in milliseconds
spent performing scroll operations.

`scroll_current`::
(integer)
Number of scroll operations currently running.

`suggest_total`::
(integer)
Total number of suggest operations.

`suggest_time`::
(<<time-units,time value>>)
Time spent performing suggest operations.

`suggest_time_in_millis`::
(integer)
Time in milliseconds
spent performing suggest operations.

`suggest_current`::
(integer)
Number of suggest operations currently running.
=======

`merges`::
(object)
Contains statistics about merge operations for the node.
+
.Properties of `merges`
[%collapsible%open]
=======
`current`::
(integer)
Number of merge operations currently running.

`current_docs`::
(integer)
Number of document merges currently running.

`current_size`::
(<<byte-units,byte value>>)
Memory used performing current document merges.

`current_size_in_bytes`::
(integer)
Memory, in bytes, used performing current document merges.

`total`::
(integer)
Total number of merge operations.

`total_time`::
(<<time-units,time value>>)
Total time spent performing merge operations.

`total_time_in_millis`::
(integer)
Total time in milliseconds
spent performing merge operations.

`total_docs`::
(integer)
Total number of merged documents.

`total_size`::
(<<byte-units,byte value>>)
Total size of document merges.

`total_size_in_bytes`::
(integer)
Total size of document merges in bytes.

`total_stopped_time`::
(<<time-units,time value>>)
Total time spent stopping merge operations.

`total_stopped_time_in_millis`::
(integer)
Total time in milliseconds
spent stopping merge operations.

`total_throttled_time`::
(<<time-units,time value>>)
Total time spent throttling merge operations.

`total_throttled_time_in_millis`::
(integer)
Total time in milliseconds
spent throttling merge operations.

`total_auto_throttle`::
(<<byte-units,byte value>>)
Size of automatically throttled merge operations.

`total_auto_throttle_in_bytes`::
(integer)
Size, in bytes, of automatically throttled merge operations.
=======

`refresh`::
(object)
Contains statistics about refresh operations for the node.
+
.Properties of `refresh`
[%collapsible%open]
=======
`total`::
(integer)
Total number of refresh operations.

`total_time`::
(<<time-units,time value>>)
Total time spent performing refresh operations.

`total_time_in_millis`::
(integer)
Total time in milliseconds
spent performing refresh operations.

`external_total`::
(integer)
Total number of external refresh operations.

`external_total_time`::
(<<time-units,time value>>)
Total time spent performing external operations.

`external_total_time_in_millis`::
(integer)
Total time in milliseconds
spent performing external operations.

`listeners`::
(integer)
Number of refresh listeners.
=======

`flush`::
(object)
Contains statistics about flush operations for the node.
+
.Properties of `flush`
[%collapsible%open]
=======
`total`::
(integer)
Number of flush operations.

`periodic`::
(integer)
Number of flush periodic operations.

`total_time`::
(<<time-units,time value>>)
Total time spent performing flush operations.

`total_time_in_millis`::
(integer)
Total time in milliseconds
spent performing flush operations.
=======

`warmer`::
(object)
Contains statistics about index warming operations for the node.
+
.Properties of `warmer`
[%collapsible%open]
=======
`current`::
(integer)
Number of active index warmers.

`total`::
(integer)
Total number of index warmers.

`total_time`::
(<<time-units,time value>>)
Total time spent performing index warming operations.

`total_time_in_millis`::
(integer)
Total time in milliseconds
spent performing index warming operations.
=======

`query_cache`::
(object)
Contains statistics about the query cache across all shards assigned to the
node.
+
.Properties of `query_cache`
[%collapsible%open]
=======
`memory_size`::
(<<byte-units,byte value>>)
Total amount of memory used for the query cache across all shards assigned to
the node.

`memory_size_in_bytes`::
(integer)
Total amount of memory, in bytes, used for the query cache across all shards
assigned to the node.

`total_count`::
(integer)
Total count of hits, misses, and cached queries
in the query cache.

`hit_count`::
(integer)
Number of query cache hits.

`miss_count`::
(integer)
Number of query cache misses.

`cache_size`::
(integer)
Size, in bytes, of the query cache.

`cache_count`::
(integer)
Count of queries
in the query cache.

`evictions`::
(integer)
Number of query cache evictions.
=======

`fielddata`::
(object)
Contains statistics about the field data cache across all shards
assigned to the node.
+
.Properties of `fielddata`
[%collapsible%open]
=======
`memory_size`::
(<<byte-units,byte value>>)
Total amount of memory used for the field data cache across all shards
assigned to the node.

`memory_size_in_bytes`::
(integer)
Total amount of memory, in bytes, used for the field data cache across all
shards assigned to the node.

`evictions`::
(integer)
Number of fielddata evictions.
=======

`completion`::
(object)
Contains statistics about completions across all shards assigned to the node.
+
.Properties of `completion`
[%collapsible%open]
=======
`size`::
(<<byte-units,byte value>>)
Total amount of memory used for completion across all shards assigned to
the node.

`size_in_bytes`::
(integer)
Total amount of memory, in bytes, used for completion across all shards assigned
to the node.
=======

`segments`::
(object)
Contains statistics about segments across all shards assigned to the node.
+
.Properties of `segments`
[%collapsible%open]
=======
`count`::
(integer)
Number of segments.

`memory`::
(<<byte-units,byte value>>)
Total amount of memory used for segments across all shards assigned to the
node.

`memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for segments across all shards assigned
to the node.

`terms_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for terms across all shards assigned to the node.

`terms_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for terms across all shards assigned to
the node.

`stored_fields_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for stored fields across all shards assigned to
the node.

`stored_fields_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for stored fields across all shards
assigned to the node.

`term_vectors_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for term vectors across all shards assigned to
the node.

`term_vectors_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for term vectors across all shards
assigned to the node.

`norms_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for normalization factors across all shards assigned
to the node.

`norms_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for normalization factors across all
shards assigned to the node.

`points_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for points across all shards assigned to the node.

`points_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for points across all shards assigned to
the node.

`doc_values_memory`::
(<<byte-units,byte value>>)
Total amount of memory used for doc values across all shards assigned to
the node.

`doc_values_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used for doc values across all shards assigned
to the node.

`index_writer_memory`::
(<<byte-units,byte value>>)
Total amount of memory used by all index writers across all shards assigned to
the node.

`index_writer_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used by all index writers across all shards
assigned to the node.

`version_map_memory`::
(<<byte-units,byte value>>)
Total amount of memory used by all version maps across all shards assigned to
the node.

`version_map_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used by all version maps across all shards
assigned to the node.

`fixed_bit_set`::
(<<byte-units,byte value>>)
Total amount of memory used by fixed bit sets across all shards assigned to
the node.
+
Fixed bit sets are used for nested object field types and
type filters for <<parent-join,join>> fields.

`fixed_bit_set_memory_in_bytes`::
(integer)
Total amount of memory, in bytes, used by fixed bit sets across all shards
assigned to the node.
+
Fixed bit sets are used for nested object field types and
type filters for <<parent-join,join>> fields.

`max_unsafe_auto_id_timestamp`::
(integer)
Time of the most recently retried indexing request. Recorded in milliseconds
since the {wikipedia}/Unix_time[Unix Epoch].

`file_sizes`::
(object)
Contains statistics about the size of the segment file.
+
.Properties of `file_sizes`
[%collapsible%open]
========
`size`::
(<<byte-units,byte value>>)
Size of the segment file.

`size_in_bytes`::
(integer)
Size, in bytes,
of the segment file.

`description`::
(string)
Description of the segment file.
========
=======

`translog`::
(object)
Contains statistics about transaction log operations for the node.
+
.Properties of `translog`
[%collapsible%open]
=======
`operations`::
(integer)
Number of transaction log operations.

`size`::
(<<byte-units,byte value>>)
Size of the transaction log.

`size_in_bytes`::
(integer)
Size, in bytes, of the transaction log.

`uncommitted_operations`::
(integer)
Number of uncommitted transaction log operations.

`uncommitted_size`::
(<<byte-units,byte value>>)
Size of uncommitted transaction log operations.

`uncommitted_size_in_bytes`::
(integer)
Size, in bytes, of uncommitted transaction log operations.

`earliest_last_modified_age`::
(integer)
Earliest last modified age
for the transaction log.
=======

`request_cache`::
(object)
Contains statistics about the request cache across all shards assigned to the
node.
+
.Properties of `request_cache`
[%collapsible%open]
=======
`memory_size`::
(<<byte-units,byte value>>)
Memory used by the request cache.

`memory_size_in_bytes`::
(integer)
Memory, in bytes, used by the request cache.

`evictions`::
(integer)
Number of request cache operations.

`hit_count`::
(integer)
Number of request cache hits.

`miss_count`::
(integer)
Number of request cache misses.
=======

`recovery`::
(object)
Contains statistics about recovery operations for the node.
+
.Properties of `recovery`
[%collapsible%open]
=======
`current_as_source`::
(integer)
Number of recoveries
that used an index shard as a source.

`current_as_target`::
(integer)
Number of recoveries
that used an index shard as a target.

`throttle_time`::
(<<time-units,time value>>)
Time by which recovery operations were delayed due to throttling.

`throttle_time_in_millis`::
(integer)
Time in milliseconds
recovery operations were delayed due to throttling.
=======
======

[[cluster-nodes-stats-api-response-body-os]]
`os`::
(object)
Contains statistics about the operating system for the node.
+
.Properties of `os`
[%collapsible%open]
======
`timestamp`::
(integer)
Last time the operating system statistics were refreshed. Recorded in
milliseconds since the {wikipedia}/Unix_time[Unix Epoch].

`cpu`::
(object)
Contains statistics about CPU usage for the node.
+
.Properties of `cpu`
[%collapsible%open]
=======
`percent`::
(integer)
Recent CPU usage for the whole system, or `-1` if not supported.

`load_average`::
(object)
Contains statistics about load averages on the system.
+
.Properties of `load_average`
[%collapsible%open]
========
`1m`::
(float)
One-minute load average on the system (field is not present if one-minute load
average is not available).

`5m`::
(float)
Five-minute load average on the system (field is not present if five-minute load
average is not available).

`15m`::
(float)
Fifteen-minute load average on the system (field is not present if
fifteen-minute load average is not available).
========
=======

`mem`::
(object)
Contains statistics about memory usage for the node.
+
.Properties of `mem`
[%collapsible%open]
=======
`total`::
(<<byte-units,byte value>>)
Total amount of physical memory.

`total_in_bytes`::
(integer)
Total amount of physical memory in bytes.

`free`::
(<<byte-units,byte value>>)
Amount of free physical memory.

`free_in_bytes`::
(integer)
Amount of free physical memory in bytes.

`used`::
(<<byte-units,byte value>>)
Amount of used physical memory.

`used_in_bytes`::
(integer)
Amount of used physical memory in bytes.

`free_percent`::
(integer)
Percentage of free memory.

`used_percent`::
(integer)
Percentage of used memory.
=======

`swap`::
(object)
Contains statistics about swap space for the node.
+
.Properties of `swap`
[%collapsible%open]
=======
`total`::
(<<byte-units,byte value>>)
Total amount of swap space.

`total_in_bytes`::
(integer)
Total amount of swap space in bytes.

`free`::
(<<byte-units,byte value>>)
Amount of free swap space.

`free_in_bytes`::
(integer)
Amount of free swap space in bytes.

`used`::
(<<byte-units,byte value>>)
Amount of used swap space.

`used_in_bytes`::
(integer)
Amount of used swap space in bytes.
=======

`cgroup` (Linux only)::
(object)
Contains cgroup statistics for the node.
+
NOTE: For the cgroup stats to be visible, cgroups must be compiled into the
kernel, the `cpu` and `cpuacct` cgroup subsystems must be configured and stats
must be readable from `/sys/fs/cgroup/cpu` and `/sys/fs/cgroup/cpuacct`.
+
.Properties of `cgroup`
[%collapsible%open]
=======

`cpuacct` (Linux only)::
(object)
Contains statistics about `cpuacct` control group for the node.
+
.Properties of `cpuacct`
[%collapsible%open]
========
`control_group` (Linux only)::
(string)
The `cpuacct` control group to which the {es} process belongs.

`usage_nanos` (Linux only)::
(integer)
The total CPU time (in nanoseconds) consumed by all tasks in the same cgroup
as the {es} process.
========

`cpu` (Linux only)::
(object)
Contains statistics about `cpu` control group for the node.
+
.Properties of `cpu`
[%collapsible%open]
========
`control_group` (Linux only)::
(string)
The `cpu` control group to which the {es} process belongs.

`cfs_period_micros` (Linux only)::
(integer)
The period of time (in microseconds) for how regularly all tasks in the same
cgroup as the {es} process should have their access to CPU resources
reallocated.

`cfs_quota_micros` (Linux only)::
(integer)
The total amount of time (in microseconds) for which all tasks in
the same cgroup as the {es} process can run during one period
`cfs_period_micros`.

`stat` (Linux only)::
(object)
Contains CPU statistics for the node.
+
.Properties of `stat`
[%collapsible%open]
=========
`number_of_elapsed_periods` (Linux only)::
(integer)
The number of reporting periods (as specified by
`cfs_period_micros`) that have elapsed.

`number_of_times_throttled` (Linux only)::
(integer)
The number of times all tasks in the same cgroup as the {es} process have
been throttled.

`time_throttled_nanos` (Linux only)::
(integer)
The total amount of time (in nanoseconds) for which all tasks in the same
cgroup as the {es} process have been throttled.
=========
========

`memory` (Linux only)::
(object)
Contains statistics about the `memory` control group for the node.
+
.Properties of `memory`
[%collapsible%open]
========
`control_group` (Linux only)::
(string)
The `memory` control group to which the {es} process belongs.

`limit_in_bytes` (Linux only)::
(string)
The maximum amount of user memory (including file cache) allowed for all
tasks in the same cgroup as the {es} process. This value can be too big to
store in a `long`, so is returned as a string so that the value returned can
exactly match what the underlying operating system interface returns. Any
value that is too large to parse into a `long` almost certainly means no
limit has been set for the cgroup.

`usage_in_bytes` (Linux only)::
(string)
The total current memory usage by processes in the cgroup (in bytes) by all
tasks in the same cgroup as the {es} process. This value is stored as a
string for consistency with `limit_in_bytes`.
========
=======
======

[[cluster-nodes-stats-api-response-body-process]]
`process`::
(object)
Contains process statistics for the node.
+
.Properties of `process`
[%collapsible%open]
======
`timestamp`::
(integer)
Last time the statistics were refreshed. Recorded in milliseconds
since the {wikipedia}/Unix_time[Unix Epoch].

`open_file_descriptors`::
(integer)
Number of opened file descriptors associated with the current  or
`-1` if not supported.

`max_file_descriptors`::
(integer)
Maximum number of file descriptors allowed on the system, or `-1` if not
supported.

`cpu`::
(object)
Contains CPU statistics for the node.
+
.Properties of `cpu`
[%collapsible%open]
=======
`percent`::
(integer)
CPU usage in percent, or `-1` if not known at the time the stats are
computed.

`total`::
(<<time-units,time value>>)
CPU time used by the process on which the Java virtual machine is running.

`total_in_millis`::
(integer)
CPU time (in milliseconds) used by the process on which the Java virtual
machine is running, or `-1` if not supported.
=======

`mem`::
(object)
Contains virtual memory statistics for the node.
+
.Properties of `mem`
[%collapsible%open]
=======
`total_virtual`::
(<<byte-units,byte value>>)
Size of virtual memory that is guaranteed to be available to the
running process.

`total_virtual_in_bytes`::
(integer)
Size in bytes of virtual memory that is guaranteed to be available to the
running process.
=======
======

[[cluster-nodes-stats-api-response-body-jvm]]
`jvm`::
(object)
Contains Java Virtual Machine (JVM) statistics for the node.
+
.Properties of `jvm`
[%collapsible%open]
======
`timestamp`::
(integer)
Last time JVM statistics were refreshed.

`uptime`::
(<<time-units,time value>>)
JVM uptime.

`uptime_in_millis`::
(integer)
JVM uptime in milliseconds.

`mem`::
(object)
Contains JVM memory usage statistics for the node.
+
.Properties of `mem`
[%collapsible%open]
=======
`heap_used`::
(<<byte-units,byte value>>)
Memory currently in use by the heap.

`heap_used_in_bytes`::
(integer)
Memory, in bytes, currently in use by the heap.

`heap_used_percent`::
(integer)
Percentage of memory currently in use by the heap.

`heap_committed`::
(<<byte-units,byte value>>)
Amount of memory available for use by the heap.

`heap_committed_in_bytes`::
(integer)
Amount of memory, in bytes, available for use by the heap.

`heap_max`::
(<<byte-units,byte value>>)
Maximum amount of memory available for use by the heap.

`heap_max_in_bytes`::
(integer)
Maximum amount of memory, in bytes, available for use by the heap.

`non_heap_used`::
(<<byte-units,byte value>>)
Non-heap memory used.

`non_heap_used_in_bytes`::
(integer)
Non-heap memory used, in bytes.

`non_heap_committed`::
(<<byte-units,byte value>>)
Amount of non-heap memory available.

`non_heap_committed_in_bytes`::
(integer)
Amount of non-heap memory available, in bytes.

`pools`::
(object)
Contains statistics about heap memory usage for the node.
+
.Properties of `pools`
[%collapsible%open]
========

`young`::
(object)
Contains statistics about memory usage by the young generation heap for the
node.
+
.Properties of `young`
[%collapsible%open]
=========
`used`::
(<<byte-units,byte value>>)
Memory used by the young generation heap.

`used_in_bytes`::
(integer)
Memory, in bytes, used by the young generation heap.

`max`::
(<<byte-units,byte value>>)
Maximum amount of memory available for use by the young generation heap.

`max_in_bytes`::
(integer)
Maximum amount of memory, in bytes, available for use by the young generation
heap.

`peak_used`::
(<<byte-units,byte value>>)
Largest amount of memory historically used by the young generation heap.

`peak_used_in_bytes`::
(integer)
Largest amount of memory, in bytes, historically used by the young generation
heap.

`peak_max`::
(<<byte-units,byte value>>)
Largest amount of memory historically used by the young generation heap.

`peak_max_in_bytes`::
(integer)
Largest amount of memory, in bytes, historically used by the young generation
heap.
=========

`survivor`::
(object)
Contains statistics about memory usage by the survivor space for the node.
+
.Properties of `survivor`
[%collapsible%open]
=========
`used`::
(<<byte-units,byte value>>)
Memory used by the survivor space.

`used_in_bytes`::
(integer)
Memory, in bytes, used by the survivor space.

`max`::
(<<byte-units,byte value>>)
Maximum amount of memory available for use by the survivor space.

`max_in_bytes`::
(integer)
Maximum amount of memory, in bytes, available for use by the survivor space.

`peak_used`::
(<<byte-units,byte value>>)
Largest amount of memory historically used by the survivor space.

`peak_used_in_bytes`::
(integer)
Largest amount of memory, in bytes, historically used by the survivor space.

`peak_max`::
(<<byte-units,byte value>>)
Largest amount of memory historically used by the survivor space.

`peak_max_in_bytes`::
(integer)
Largest amount of memory, in bytes, historically used by the survivor space.
=========

`old`::
(object)
Contains statistics about memory usage by the old generation heap for the node.
+
.Properties of `old`
[%collapsible%open]
=========
`used`::
(<<byte-units,byte value>>)
Memory used by the old generation heap.

`used_in_bytes`::
(integer)
Memory, in bytes, used by the old generation heap.

`max`::
(<<byte-units,byte value>>)
Maximum amount of memory available for use by the old generation heap.

`max_in_bytes`::
(integer)
Maximum amount of memory, in bytes, available for use by the old generation
heap.

`peak_used`::
(<<byte-units,byte value>>)
Largest amount of memory historically used by the old generation heap.

`peak_used_in_bytes`::
(integer)
Largest amount of memory, in bytes, historically used by the old generation
heap.

`peak_max`::
(<<byte-units,byte value>>)
Highest memory limit historically available for use by the old generation heap.

`peak_max_in_bytes`::
(integer)
Highest memory limit, in bytes, historically available for use by the old
generation heap.
=========
========
=======

`threads`::
(object)
Contains statistics about JVM thread usage for the node.
+
.Properties of `threads`
[%collapsible%open]
=======
`count`::
(integer)
Number of active threads in use by JVM.

`peak_count`::
(integer)
Highest number of threads used by JVM.
=======

`gc`::
(object)
Contains statistics about JVM garbage collectors for the node.
+
.Properties of `gc`
[%collapsible%open]
=======
`collectors`::
(object)
Contains statistics about JVM garbage collectors for the node.
+
.Properties of `collectors`
[%collapsible%open]
========
`young`::
(object)
Contains statistics about JVM garbage collectors that collect young generation
objects for the node.
+
.Properties of `young`
[%collapsible%open]
=========
`collection_count`::
(integer)
Number of JVM garbage collectors that collect young generation objects.

`collection_time`::
(<<time-units,time value>>)
Total time spent by JVM collecting young generation objects.

`collection_time_in_millis`::
(integer)
Total time in milliseconds spent by JVM collecting young generation objects.
=========

`old`::
(object)
Contains statistics about JVM garbage collectors that collect old generation
objects for the node.
+
.Properties of `old`
[%collapsible%open]
=========
`collection_count`::
(integer)
Number of JVM garbage collectors that collect old generation objects.

`collection_time`::
(<<time-units,time value>>)
Total time spent by JVM collecting old generation objects.

`collection_time_in_millis`::
(integer)
Total time in milliseconds spent by JVM collecting old generation objects.
=========
========
=======

`buffer_pools`::
(object)
Contains statistics about JVM buffer pools for the node.
+
.Properties of `buffer_pools`
[%collapsible%open]
=======
`mapped`::
(object)
Contains statistics about mapped JVM buffer pools for the node.
+
.Properties of `mapped`
[%collapsible%open]
========
`count`::
(integer)
Number of mapped buffer pools.

`used`::
(<<byte-units,byte value>>)
Size of mapped buffer pools.

`used_in_bytes`::
(integer)
Size, in bytes, of mapped buffer pools.

`total_capacity`::
(<<byte-units,byte value>>)
Total capacity of mapped buffer pools.

`total_capacity_in_bytes`::
(integer)
Total capacity, in bytes, of mapped buffer pools.
========

`direct`::
(object)
Contains statistics about direct JVM buffer pools for the node.
+
.Properties of `direct`
[%collapsible%open]
========
`count`::
(integer)
Number of direct buffer pools.

`used`::
(<<byte-units,byte value>>)
Size of direct buffer pools.

`used_in_bytes`::
(integer)
Size, in bytes, of direct buffer pools.

`total_capacity`::
(<<byte-units,byte value>>)
Total capacity of direct buffer pools.

`total_capacity_in_bytes`::
(integer)
Total capacity, in bytes, of direct buffer pools.
========
=======

`classes`::
(object)
Contains statistics about classes loaded by JVM for the node.
+
.Properties of `classes`
[%collapsible%open]
=======
`current_loaded_count`::
(integer)
Number of classes currently loaded by JVM.

`total_loaded_count`::
(integer)
Total number of classes loaded since the JVM started.

`total_unloaded_count`::
(integer)
Total number of classes unloaded since the JVM started.
=======
======

[[cluster-nodes-stats-api-response-body-threadpool]]
`thread_pool`::
(object)
Contains thread pool statistics for the node
+
.Properties of `thread_pool`
[%collapsible%open]
======
`<thread_pool_name>`::
(object)
Contains statistics about the thread pool for the node.
+
.Properties of `<thread_pool_name>`
[%collapsible%open]
=======
`threads`::
(integer)
Number of threads in the thread pool.

`queue`::
(integer)
Number of tasks in queue for the thread pool.

`active`::
(integer)
Number of active threads in the thread pool.

`rejected`::
(integer)
Number of tasks rejected by the thread pool executor.

`largest`::
(integer)
Highest number of active threads in the thread pool.

`completed`::
(integer)
Number of tasks completed by the thread pool executor.
=======
======

[[cluster-nodes-stats-api-response-body-fs]]
`fs`::
(object)
Contains file store statistics for the node.
+
.Properties of `fs`
[%collapsible%open]
======
`timestamp`::
(integer)
Last time the file stores statistics were refreshed. Recorded in
milliseconds since the {wikipedia}/Unix_time[Unix Epoch].

`total`::
(object)
Contains statistics for all file stores of the node.
+
.Properties of `total`
[%collapsible%open]
=======
`total`::
(<<byte-units,byte value>>)
Total size of all file stores.

`total_in_bytes`::
(integer)
Total size (in bytes) of all file stores.

`free`::
(<<byte-units,byte value>>)
Total unallocated disk space in all file stores.

`free_in_bytes`::
(integer)
Total number of unallocated bytes in all file stores.

`available`::
(<<byte-units,byte value>>)
Total disk space available to this Java virtual machine on all file
stores. Depending on OS or process level restrictions, this might appear
less than `free`. This is the actual amount of free disk
space the {es} node can utilise.

`available_in_bytes`::
(integer)
Total number of bytes available to this Java virtual machine on all file
stores. Depending on OS or process level restrictions, this might appear
less than `free_in_bytes`. This is the actual amount of free disk
space the {es} node can utilise.
=======

[[cluster-nodes-stats-fs-data]]
`data`::
(array of objects)
List of all file stores.
+
.Properties of `data`
[%collapsible%open]
=======
`path`::
(string)
Path to the file store.

`mount`::
(string)
Mount point of the file store (ex: /dev/sda2).

`type`::
(string)
Type of the file store (ex: ext4).

`total`::
(<<byte-units,byte value>>)
Total size of the file store.

`total_in_bytes`::
(integer)
Total size (in bytes) of the file store.

`free`::
(<<byte-units,byte value>>)
Total amount of unallocated disk space in the file store.

`free_in_bytes`::
(integer)
Total number of unallocated bytes in the file store.

`available`::
(<<byte-units,byte value>>)
Total amount of disk space available to this Java virtual machine on this file
store.

`available_in_bytes`::
(integer)
Total number of bytes available to this Java virtual machine on this file
store.
=======

`io_stats` (Linux only)::
(objects)
Contains I/O statistics for the node.
+
.Properties of `io_stats`
[%collapsible%open]
=======
`devices` (Linux only)::
(array)
Array of disk metrics for each device that is backing an {es} data path.
These disk metrics are probed periodically and averages between the last
probe and the current probe are computed.
+
.Properties of `devices`
[%collapsible%open]
========
`device_name` (Linux only)::
(string)
The Linux device name.

`operations` (Linux only)::
(integer)
The total number of read and write operations for the device completed since
starting {es}.

`read_operations` (Linux only)::
(integer)
The total number of read operations for the device completed since starting
{es}.

`write_operations` (Linux only)::
(integer)
The total number of write operations for the device completed since starting
{es}.

`read_kilobytes` (Linux only)::
(integer)
The total number of kilobytes read for the device since starting {es}.

`write_kilobytes` (Linux only)::
(integer)
The total number of kilobytes written for the device since starting {es}.
========

`operations` (Linux only)::
    (integer)
    The total number of read and write operations across all devices used by
    {es} completed since starting {es}.

`read_operations` (Linux only)::
    (integer)
    The total number of read operations for across all devices used by {es}
    completed since starting {es}.

`write_operations` (Linux only)::
    (integer)
    The total number of write operations across all devices used by {es}
    completed since starting {es}.

`read_kilobytes` (Linux only)::
    (integer)
    The total number of kilobytes read across all devices used by {es} since
    starting {es}.

`write_kilobytes` (Linux only)::
    (integer)
    The total number of kilobytes written across all devices used by {es} since
    starting {es}.
=======
======

[[cluster-nodes-stats-api-response-body-transport]]
`transport`::
(object)
Contains transport statistics for the node.
+
.Properties of `transport`
[%collapsible%open]
======
`server_open`::
(integer)
Current number of inbound TCP connections used for internal communication between nodes.

`total_outbound_connections`::
(integer)
The cumulative number of outbound transport connections that this node has
opened since it started. Each transport connection may comprise multiple TCP
connections but is only counted once in this statistic. Transport connections
are typically <<long-lived-connections,long-lived>> so this statistic should
remain constant in a stable cluster.

`rx_count`::
(integer)
Total number of RX (receive) packets received by the node during internal
cluster communication.

`rx_size`::
(<<byte-units,byte value>>)
Size of RX packets received by the node during internal cluster communication.

`rx_size_in_bytes`::
(integer)
Size, in bytes, of RX packets received by the node during internal cluster
communication.

`tx_count`::
(integer)
Total number of TX (transmit) packets sent by the node during internal cluster
communication.

`tx_size`::
(<<byte-units,byte value>>)
Size of TX packets sent by the node during internal cluster communication.

`tx_size_in_bytes`::
(integer)
Size, in bytes, of TX packets sent by the node during internal cluster
communication.
======

[[cluster-nodes-stats-api-response-body-http]]
`http`::
(object)
Contains http statistics for the node.
+
.Properties of `http`
[%collapsible%open]
======
`current_open`::
(integer)
Current number of open HTTP connections for the node.

`total_opened`::
(integer)
Total number of HTTP connections opened for the node.
======

[[cluster-nodes-stats-api-response-body-breakers]]
`breakers`::
(object)
Contains circuit breaker statistics for the node.
+
.Properties of `breakers`
[%collapsible%open]
======
`<circuit_breaker_name>`::
(object)
Contains statistics for the circuit breaker.
+
.Properties of `<circuit_breaker_name>`
[%collapsible%open]
=======
`limit_size_in_bytes`::
(integer)
Memory limit, in bytes, for the circuit breaker.

`limit_size`::
(<<byte-units,byte value>>)
Memory limit for the circuit breaker.

`estimated_size_in_bytes`::
(integer)
Estimated memory used, in bytes, for the operation.

`estimated_size`::
(<<byte-units,byte value>>)
Estimated memory used for the operation.

`overhead`::
(float)
A constant that all estimates for the circuit breaker are multiplied with to
calculate a final estimate.

`tripped`::
(integer)
Total number of times the circuit breaker has been triggered and prevented an
out of memory error.
=======
======

[[cluster-nodes-stats-api-response-body-script]]
`script`::
(object)
Contains script statistics for the node.
+
.Properties of `script`
[%collapsible%open]
======
`compilations`::
(integer)
Total number of inline script compilations performed by the node.

`cache_evictions`::
(integer)
Total number of times the script cache has evicted old data.

`compilation_limit_triggered`::
(integer)
Total number of times the <<script-compilation-circuit-breaker,script
compilation>> circuit breaker has limited inline script compilations.
======

[[cluster-nodes-stats-api-response-body-discovery]]
`discovery`::
(object)
Contains node discovery statistics for the node.
+
.Properties of `discovery`
[%collapsible%open]
======
`cluster_state_queue`::
(object)
Contains statistics for the cluster state queue of the node.
+
.Properties of `cluster_state_queue`
[%collapsible%open]
=======
`total`::
(integer)
Total number of cluster states in queue.

`pending`::
(integer)
Number of pending cluster states in queue.

`committed`::
(integer)
Number of committed cluster states in queue.
=======

`published_cluster_states`::
(object)
Contains statistics for the published cluster states of the node.
+
.Properties of `published_cluster_states`
[%collapsible%open]
=======
`full_states`::
(integer)
Number of published cluster states.

`incompatible_diffs`::
(integer)
Number of incompatible differences between published cluster states.

`compatible_diffs`::
(integer)
Number of compatible differences between published cluster states.
=======
======

[[cluster-nodes-stats-api-response-body-ingest]]
`ingest`::
(object)
Contains ingest statistics for the node.
+
.Properties of `ingest`
[%collapsible%open]
======
`total`::
(object)
Contains statistics about ingest operations for the node.
+
.Properties of `total`
[%collapsible%open]
=======
`count`::
(integer)
Total number of documents ingested during the lifetime of this node.

`time`::
(<<time-units,time value>>)
Total time spent preprocessing ingest documents during the lifetime of this
node.

`time_in_millis`::
(integer)
Total time, in milliseconds, spent preprocessing ingest documents during the
lifetime of this node.

`current`::
(integer)
Total number of documents currently being ingested.

`failed`::
(integer)
Total number of failed ingest operations during the lifetime of this node.
=======

`pipelines`::
(object)
Contains statistics about ingest pipelines for the node.
+
.Properties of `pipelines`
[%collapsible%open]
=======
`<pipeline_id>`::
(object)
Contains statistics about the ingest pipeline.
+
.Properties of `<pipeline_id>`
[%collapsible%open]
========
`count`::
(integer)
Number of documents preprocessed by the ingest pipeline.

`time`::
(<<time-units,time value>>)
Total time spent preprocessing documents in the ingest pipeline.

`time_in_millis`::
(integer)
Total time, in milliseconds, spent preprocessing documents in the ingest
pipeline.

`failed`::
(integer)
Total number of failed operations for the ingest pipeline.

`processors`::
(array of objects)
Contains statistics for the ingest processors for the ingest pipeline.
+
.Properties of `processors`
[%collapsible%open]
=========
`<processor>`::
(object)
Contains statistics for the ingest processor.
+
.Properties of `<processor>`
[%collapsible%open]
==========
`count`::
(integer)
Number of documents transformed by the processor.

`time`::
(<<time-units,time value>>)
Time spent by the processor transforming documents.

`time_in_millis`::
(integer)
Time, in milliseconds, spent by the processor transforming documents.

`current`::
(integer)
Number of documents currently being transformed by the processor.

`failed`::
(integer)
Number of failed operations for the processor.
==========
=========
========
=======
======

[[cluster-nodes-stats-api-response-body-indexing-pressure]]
`indexing_pressure`::
(object)
Contains <<index-modules-indexing-pressure,indexing pressure>> statistics for the node.
+
.Properties of `indexing_pressure`
[%collapsible%open]
======
`memory`::
(object)
Contains statistics for memory consumption from indexing load.
+
.Properties of `<memory>`
[%collapsible%open]
=======
`current`::
(object)
Contains statistics for current indexing load.
+
.Properties of `<current>`
[%collapsible%open]
========
`combined_coordinating_and_primary`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the coordinating or primary stage. This
value is not the sum of coordinating and primary as a node can reuse the
coordinating memory if the primary stage is executed locally.

`combined_coordinating_and_primary_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the coordinating or primary
stage. This value is not the sum of coordinating and primary as a node can
reuse the coordinating memory if the primary stage is executed locally.

`coordinating`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the coordinating stage.

`coordinating_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the coordinating stage.

`primary`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the primary stage.

`primary_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the primary stage.

`replica`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the replica stage.

`replica_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the replica stage.

`all`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the coordinating, primary, or replica stage.

`all_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the coordinating, primary,
or replica stage.
========
`total`::
(object)
Contains statistics for the cumulative indexing load since the node started.
+
.Properties of `<total>`
[%collapsible%open]
========
`combined_coordinating_and_primary`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the coordinating or primary stage. This
value is not the sum of coordinating and primary as a node can reuse the
coordinating memory if the primary stage is executed locally.

`combined_coordinating_and_primary_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the coordinating or primary
stage. This value is not the sum of coordinating and primary as a node can
reuse the coordinating memory if the primary stage is executed locally.

`coordinating`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the coordinating stage.

`coordinating_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the coordinating stage.

`primary`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the primary stage.

`primary_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the primary stage.

`replica`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the replica stage.

`replica_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the replica stage.

`all`::
(<<byte-units,byte value>>)
Memory consumed by indexing requests in the coordinating, primary, or replica stage.

`all_in_bytes`::
(integer)
Memory consumed, in bytes, by indexing requests in the coordinating, primary,
or replica stage.

`coordinating_rejections`::
(integer)
Number of indexing requests rejected in the coordinating stage.

`primary_rejections`::
(integer)
Number of indexing requests rejected in the primary stage.

`replica_rejections`::
(integer)
Number of indexing requests rejected in the replica stage.
========
`limit`::
(<<byte-units,byte value>>)
Configured memory limit for the indexing requests. Replica requests have an
automatic limit that is 1.5x this value.

`limit_in_bytes`::
(integer)
Configured memory limit, in bytes, for the indexing requests. Replica requests
have an automatic limit that is 1.5x this value.
=======
======

[[cluster-nodes-stats-api-response-body-adaptive-selection]]
`adaptive_selection`::
(object)
Contains adaptive selection statistics for the node.
+
.Properties of `adaptive_selection`
[%collapsible%open]
======
`outgoing_searches`::
(integer)
The number of outstanding search requests from the node these stats are for
to the keyed node.

`avg_queue_size`::
(integer)
The exponentially weighted moving average queue size of search requests on
the keyed node.

`avg_service_time`::
(<<time-units,time value>>)
The exponentially weighted moving average service time of search requests on
the keyed node.

`avg_service_time_ns`::
(integer)
The exponentially weighted moving average service time, in nanoseconds, of
search requests on the keyed node.

`avg_response_time`::
(<<time-units,time value>>)
The exponentially weighted moving average response time of search requests
on the keyed node.

`avg_response_time_ns`::
(integer)
The exponentially weighted moving average response time, in nanoseconds, of
search requests on the keyed node.

`rank`::
(string)
The rank of this node; used for shard selection when routing search
requests.
======
=====
====

[[cluster-nodes-stats-api-example]]
==== {api-examples-title}

[source,console]
--------------------------------------------------
# return just indices
GET /_nodes/stats/indices

# return just os and process
GET /_nodes/stats/os,process

# return just process for node with IP address 10.0.0.1
GET /_nodes/10.0.0.1/stats/process
--------------------------------------------------

All stats can be explicitly requested via `/_nodes/stats/_all` or
`/_nodes/stats?metric=_all`.

You can get information about indices stats on `node`, `indices`, or `shards`
level.

[source,console]
--------------------------------------------------
# Fielddata summarized by node
GET /_nodes/stats/indices/fielddata?fields=field1,field2

# Fielddata summarized by node and index
GET /_nodes/stats/indices/fielddata?level=indices&fields=field1,field2

# Fielddata summarized by node, index, and shard
GET /_nodes/stats/indices/fielddata?level=shards&fields=field1,field2

# You can use wildcards for field names
GET /_nodes/stats/indices/fielddata?fields=field*
--------------------------------------------------

You can get statistics about search groups for searches executed
on this node.

[source,console]
--------------------------------------------------
# All groups with all stats
GET /_nodes/stats?groups=_all

# Some groups from just the indices stats
GET /_nodes/stats/indices?groups=foo,bar
--------------------------------------------------

[[cluster-nodes-stats-ingest-ex]]
===== Retrieve ingest statistics only

To return only ingest-related node statistics, set the `<metric>` path
parameter to `ingest` and use the
<<common-options-response-filtering,`filter_path`>> query parameter.

[source,console]
--------------------------------------------------
GET /_nodes/stats/ingest?filter_path=nodes.*.ingest
--------------------------------------------------

You can use the `metric` and `filter_path` query parameters to get the same
response.

[source,console]
--------------------------------------------------
GET /_nodes/stats?metric=ingest&filter_path=nodes.*.ingest
--------------------------------------------------

To further refine the response, change the `filter_path` value.
For example, the following request only returns ingest pipeline statistics.

[source,console]
--------------------------------------------------
GET /_nodes/stats?metric=ingest&filter_path=nodes.*.ingest.pipelines
--------------------------------------------------
",12276,True,2566.7365667248887,median
"== AMQP Component

*Available as of Camel version 1.2*

The *amqp:* component supports the http://www.amqp.org/[AMQP 1.0
protocol] using the JMS Client API of the http://qpid.apache.org/[Qpid]
project. In case you want to use AMQP 0.9 (in particular RabbitMQ) you
might also be interested in the link:rabbitmq.html[Camel RabbitMQ]
component. Please keep in mind that prior to the Camel 2.17.0 AMQP
component supported AMQP 0.9 and above, however since Camel 2.17.0 it
supports only AMQP 1.0.

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-amqp</artifactId>
    <version>${camel.version}</version> <!-- use the same version as your Camel core version -->
</dependency>
------------------------------------------------------------------------------------------------

### URI format

[source,java]
---------------------------------------------
amqp:[queue:|topic:]destinationName[?options]
---------------------------------------------

### AMQP Options

You can specify all of the various configuration options of the
link:../../../../camel-jms/src/main/docs/readme.html[JMS] component after the destination name.




// component options: START
The AMQP component supports 79 options which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *configuration* (advanced) | To use a shared JMS configuration |  | JmsConfiguration
| *acceptMessagesWhile Stopping* (consumer) | Specifies whether the consumer accept messages while it is stopping. You may consider enabling this option if you start and stop JMS routes at runtime while there are still messages enqueued on the queue. If this option is false and you stop the JMS route then messages may be rejected and the JMS broker would have to attempt redeliveries which yet again may be rejected and eventually the message may be moved at a dead letter queue on the JMS broker. To avoid this its recommended to enable this option. | false | boolean
| *allowReplyManagerQuick Stop* (consumer) | Whether the DefaultMessageListenerContainer used in the reply managers for request-reply messaging allow the DefaultMessageListenerContainer.runningAllowed flag to quick stop in case JmsConfigurationisAcceptMessagesWhileStopping is enabled and org.apache.camel.CamelContext is currently being stopped. This quick stop ability is enabled by default in the regular JMS consumers but to enable for reply managers you must enable this flag. | false | boolean
| *acknowledgementMode* (consumer) | The JMS acknowledgement mode defined as an Integer. Allows you to set vendor-specific extensions to the acknowledgment mode.For the regular modes it is preferable to use the acknowledgementModeName instead. |  | int
| *eagerLoadingOf Properties* (consumer) | Enables eager loading of JMS properties as soon as a message is loaded which generally is inefficient as the JMS properties may not be required but sometimes can catch early any issues with the underlying JMS provider and the use of JMS properties | false | boolean
| *acknowledgementModeName* (consumer) | The JMS acknowledgement name which is one of: SESSION_TRANSACTED CLIENT_ACKNOWLEDGE AUTO_ACKNOWLEDGE DUPS_OK_ACKNOWLEDGE | AUTO_ ACKNOWLEDGE | String
| *autoStartup* (consumer) | Specifies whether the consumer container should auto-startup. | true | boolean
| *cacheLevel* (consumer) | Sets the cache level by ID for the underlying JMS resources. See cacheLevelName option for more details. |  | int
| *cacheLevelName* (consumer) | Sets the cache level by name for the underlying JMS resources. Possible values are: CACHE_AUTO CACHE_CONNECTION CACHE_CONSUMER CACHE_NONE and CACHE_SESSION. The default setting is CACHE_AUTO. See the Spring documentation and Transactions Cache Levels for more information. | CACHE_AUTO | String
| *replyToCacheLevelName* (producer) | Sets the cache level by name for the reply consumer when doing request/reply over JMS. This option only applies when using fixed reply queues (not temporary). Camel will by default use: CACHE_CONSUMER for exclusive or shared w/ replyToSelectorName. And CACHE_SESSION for shared without replyToSelectorName. Some JMS brokers such as IBM WebSphere may require to set the replyToCacheLevelName=CACHE_NONE to work. Note: If using temporary queues then CACHE_NONE is not allowed and you must use a higher value such as CACHE_CONSUMER or CACHE_SESSION. |  | String
| *clientId* (common) | Sets the JMS client ID to use. Note that this value if specified must be unique and can only be used by a single JMS connection instance. It is typically only required for durable topic subscriptions. If using Apache ActiveMQ you may prefer to use Virtual Topics instead. |  | String
| *concurrentConsumers* (consumer) | Specifies the default number of concurrent consumers when consuming from JMS (not for request/reply over JMS). See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. When doing request/reply over JMS then the option replyToConcurrentConsumers is used to control number of concurrent consumers on the reply message listener. | 1 | int
| *replyToConcurrent Consumers* (producer) | Specifies the default number of concurrent consumers when doing request/reply over JMS. See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. | 1 | int
| *connectionFactory* (common) | The connection factory to be use. A connection factory must be configured either on the component or endpoint. |  | ConnectionFactory
| *username* (security) | Username to use with the ConnectionFactory. You can also configure username/password directly on the ConnectionFactory. |  | String
| *password* (security) | Password to use with the ConnectionFactory. You can also configure username/password directly on the ConnectionFactory. |  | String
| *deliveryPersistent* (producer) | Specifies whether persistent delivery is used by default. | true | boolean
| *deliveryMode* (producer) | Specifies the delivery mode to be used. Possibles values are those defined by javax.jms.DeliveryMode. NON_PERSISTENT = 1 and PERSISTENT = 2. |  | Integer
| *durableSubscriptionName* (common) | The durable subscriber name for specifying durable topic subscriptions. The clientId option must be configured as well. |  | String
| *exceptionListener* (advanced) | Specifies the JMS Exception Listener that is to be notified of any underlying JMS exceptions. |  | ExceptionListener
| *errorHandler* (advanced) | Specifies a org.springframework.util.ErrorHandler to be invoked in case of any uncaught exceptions thrown while processing a Message. By default these exceptions will be logged at the WARN level if no errorHandler has been configured. You can configure logging level and whether stack traces should be logged using errorHandlerLoggingLevel and errorHandlerLogStackTrace options. This makes it much easier to configure than having to code a custom errorHandler. |  | ErrorHandler
| *errorHandlerLogging Level* (logging) | Allows to configure the default errorHandler logging level for logging uncaught exceptions. | WARN | LoggingLevel
| *errorHandlerLogStack Trace* (logging) | Allows to control whether stacktraces should be logged or not by the default errorHandler. | true | boolean
| *explicitQosEnabled* (producer) | Set if the deliveryMode priority or timeToLive qualities of service should be used when sending messages. This option is based on Spring's JmsTemplate. The deliveryMode priority and timeToLive options are applied to the current endpoint. This contrasts with the preserveMessageQos option which operates at message granularity reading QoS properties exclusively from the Camel In message headers. | false | boolean
| *exposeListenerSession* (consumer) | Specifies whether the listener session should be exposed when consuming messages. | false | boolean
| *idleTaskExecutionLimit* (advanced) | Specifies the limit for idle executions of a receive task not having received any message within its execution. If this limit is reached the task will shut down and leave receiving to other executing tasks (in the case of dynamic scheduling; see the maxConcurrentConsumers setting). There is additional doc available from Spring. | 1 | int
| *idleConsumerLimit* (advanced) | Specify the limit for the number of consumers that are allowed to be idle at any given time. | 1 | int
| *maxConcurrentConsumers* (consumer) | Specifies the maximum number of concurrent consumers when consuming from JMS (not for request/reply over JMS). See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. When doing request/reply over JMS then the option replyToMaxConcurrentConsumers is used to control number of concurrent consumers on the reply message listener. |  | int
| *replyToMaxConcurrent Consumers* (producer) | Specifies the maximum number of concurrent consumers when using request/reply over JMS. See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. |  | int
| *replyOnTimeoutToMax ConcurrentConsumers* (producer) | Specifies the maximum number of concurrent consumers for continue routing when timeout occurred when using request/reply over JMS. | 1 | int
| *maxMessagesPerTask* (advanced) | The number of messages per task. -1 is unlimited. If you use a range for concurrent consumers (eg min max) then this option can be used to set a value to eg 100 to control how fast the consumers will shrink when less work is required. | -1 | int
| *messageConverter* (advanced) | To use a custom Spring org.springframework.jms.support.converter.MessageConverter so you can be in control how to map to/from a javax.jms.Message. |  | MessageConverter
| *mapJmsMessage* (advanced) | Specifies whether Camel should auto map the received JMS message to a suited payload type such as javax.jms.TextMessage to a String etc. | true | boolean
| *messageIdEnabled* (advanced) | When sending specifies whether message IDs should be added. This is just an hint to the JMS broker.If the JMS provider accepts this hint these messages must have the message ID set to null; if the provider ignores the hint the message ID must be set to its normal unique value | true | boolean
| *messageTimestampEnabled* (advanced) | Specifies whether timestamps should be enabled by default on sending messages. This is just an hint to the JMS broker.If the JMS provider accepts this hint these messages must have the timestamp set to zero; if the provider ignores the hint the timestamp must be set to its normal value | true | boolean
| *alwaysCopyMessage* (producer) | If true Camel will always make a JMS message copy of the message when it is passed to the producer for sending. Copying the message is needed in some situations such as when a replyToDestinationSelectorName is set (incidentally Camel will set the alwaysCopyMessage option to true if a replyToDestinationSelectorName is set) | false | boolean
| *useMessageIDAs CorrelationID* (advanced) | Specifies whether JMSMessageID should always be used as JMSCorrelationID for InOut messages. | false | boolean
| *priority* (producer) | Values greater than 1 specify the message priority when sending (where 0 is the lowest priority and 9 is the highest). The explicitQosEnabled option must also be enabled in order for this option to have any effect. | 4 | int
| *pubSubNoLocal* (advanced) | Specifies whether to inhibit the delivery of messages published by its own connection. | false | boolean
| *receiveTimeout* (advanced) | The timeout for receiving messages (in milliseconds). | 1000 | long
| *recoveryInterval* (advanced) | Specifies the interval between recovery attempts i.e. when a connection is being refreshed in milliseconds. The default is 5000 ms that is 5 seconds. | 5000 | long
| *taskExecutor* (consumer) | Allows you to specify a custom task executor for consuming messages. |  | TaskExecutor
| *timeToLive* (producer) | When sending messages specifies the time-to-live of the message (in milliseconds). | -1 | long
| *transacted* (transaction) | Specifies whether to use transacted mode | false | boolean
| *lazyCreateTransaction Manager* (transaction) | If true Camel will create a JmsTransactionManager if there is no transactionManager injected when option transacted=true. | true | boolean
| *transactionManager* (transaction) | The Spring transaction manager to use. |  | PlatformTransaction Manager
| *transactionName* (transaction) | The name of the transaction to use. |  | String
| *transactionTimeout* (transaction) | The timeout value of the transaction (in seconds) if using transacted mode. | -1 | int
| *testConnectionOn Startup* (common) | Specifies whether to test the connection on startup. This ensures that when Camel starts that all the JMS consumers have a valid connection to the JMS broker. If a connection cannot be granted then Camel throws an exception on startup. This ensures that Camel is not started with failed connections. The JMS producers is tested as well. | false | boolean
| *asyncStartListener* (advanced) | Whether to startup the JmsConsumer message listener asynchronously when starting a route. For example if a JmsConsumer cannot get a connection to a remote JMS broker then it may block while retrying and/or failover. This will cause Camel to block while starting routes. By setting this option to true you will let routes startup while the JmsConsumer connects to the JMS broker using a dedicated thread in asynchronous mode. If this option is used then beware that if the connection could not be established then an exception is logged at WARN level and the consumer will not be able to receive messages; You can then restart the route to retry. | false | boolean
| *asyncStopListener* (advanced) | Whether to stop the JmsConsumer message listener asynchronously when stopping a route. | false | boolean
| *forceSendOriginal Message* (producer) | When using mapJmsMessage=false Camel will create a new JMS message to send to a new JMS destination if you touch the headers (get or set) during the route. Set this option to true to force Camel to send the original JMS message that was received. | false | boolean
| *requestTimeout* (producer) | The timeout for waiting for a reply when using the InOut Exchange Pattern (in milliseconds). The default is 20 seconds. You can include the header CamelJmsRequestTimeout to override this endpoint configured timeout value and thus have per message individual timeout values. See also the requestTimeoutCheckerInterval option. | 20000 | long
| *requestTimeoutChecker Interval* (advanced) | Configures how often Camel should check for timed out Exchanges when doing request/reply over JMS. By default Camel checks once per second. But if you must react faster when a timeout occurs then you can lower this interval to check more frequently. The timeout is determined by the option requestTimeout. | 1000 | long
| *transferExchange* (advanced) | You can transfer the exchange over the wire instead of just the body and headers. 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. You must enable this option on both the producer and consumer side so Camel knows the payloads is an Exchange and not a regular payload. | false | boolean
| *transferException* (advanced) | If enabled and you are using Request Reply messaging (InOut) and an Exchange failed on the consumer side then the caused Exception will be send back in response as a javax.jms.ObjectMessage. If the client is Camel the returned Exception is rethrown. This allows you to use Camel JMS as a bridge in your routing - for example using persistent queues to enable robust routing. Notice that if you also have transferExchange enabled this option takes precedence. The caught exception is required to be serializable. The original Exception on the consumer side can be wrapped in an outer exception such as org.apache.camel.RuntimeCamelException when returned to the producer. | false | boolean
| *transferFault* (advanced) | If enabled and you are using Request Reply messaging (InOut) and an Exchange failed with a SOAP fault (not exception) on the consumer side then the fault flag on MessageisFault() will be send back in the response as a JMS header with the key org.apache.camel.component.jms.JmsConstantsJMS_TRANSFER_FAULTJMS_TRANSFER_FAULT. If the client is Camel the returned fault flag will be set on the link org.apache.camel.MessagesetFault(boolean). You may want to enable this when using Camel components that support faults such as SOAP based such as cxf or spring-ws. | false | boolean
| *jmsOperations* (advanced) | Allows you to use your own implementation of the org.springframework.jms.core.JmsOperations interface. Camel uses JmsTemplate as default. Can be used for testing purpose but not used much as stated in the spring API docs. |  | JmsOperations
| *destinationResolver* (advanced) | A pluggable org.springframework.jms.support.destination.DestinationResolver that allows you to use your own resolver (for example to lookup the real destination in a JNDI registry). |  | DestinationResolver
| *replyToType* (producer) | Allows for explicitly specifying which kind of strategy to use for replyTo queues when doing request/reply over JMS. Possible values are: Temporary Shared or Exclusive. By default Camel will use temporary queues. However if replyTo has been configured then Shared is used by default. This option allows you to use exclusive queues instead of shared ones. See Camel JMS documentation for more details and especially the notes about the implications if running in a clustered environment and the fact that Shared reply queues has lower performance than its alternatives Temporary and Exclusive. |  | ReplyToType
| *preserveMessageQos* (producer) | Set to true if you want to send message using the QoS settings specified on the message instead of the QoS settings on the JMS endpoint. The following three headers are considered JMSPriority JMSDeliveryMode and JMSExpiration. You can provide all or only some of them. If not provided Camel will fall back to use the values from the endpoint instead. So when using this option the headers override the values from the endpoint. The explicitQosEnabled option by contrast will only use options set on the endpoint and not values from the message header. | false | boolean
| *asyncConsumer* (consumer) | Whether the JmsConsumer processes the Exchange asynchronously. If enabled then the JmsConsumer may pickup the next message from the JMS queue while the previous message is being processed asynchronously (by the Asynchronous Routing Engine). This means that messages may be processed not 100 strictly in order. If disabled (as default) then the Exchange is fully processed before the JmsConsumer will pickup the next message from the JMS queue. Note if transacted has been enabled then asyncConsumer=true does not run asynchronously as transaction must be executed synchronously (Camel 3.0 may support async transactions). | false | boolean
| *allowNullBody* (producer) | Whether to allow sending messages with no body. If this option is false and the message body is null then an JMSException is thrown. | true | boolean
| *includeSentJMS MessageID* (producer) | Only applicable when sending to JMS destination using InOnly (eg fire and forget). Enabling this option will enrich the Camel Exchange with the actual JMSMessageID that was used by the JMS client when the message was sent to the JMS destination. | false | boolean
| *includeAllJMSX Properties* (advanced) | Whether to include all JMSXxxx properties when mapping from JMS to Camel Message. Setting this to true will include properties such as JMSXAppID and JMSXUserID etc. Note: If you are using a custom headerFilterStrategy then this option does not apply. | false | boolean
| *defaultTaskExecutor Type* (consumer) | Specifies what default TaskExecutor type to use in the DefaultMessageListenerContainer for both consumer endpoints and the ReplyTo consumer of producer endpoints. Possible values: SimpleAsync (uses Spring's SimpleAsyncTaskExecutor) or ThreadPool (uses Spring's ThreadPoolTaskExecutor with optimal values - cached threadpool-like). If not set it defaults to the previous behaviour which uses a cached thread pool for consumer endpoints and SimpleAsync for reply consumers. The use of ThreadPool is recommended to reduce thread trash in elastic configurations with dynamically increasing and decreasing concurrent consumers. |  | DefaultTaskExecutor Type
| *jmsKeyFormatStrategy* (advanced) | Pluggable strategy for encoding and decoding JMS keys so they can be compliant with the JMS specification. Camel provides two implementations out of the box: default and passthrough. The default strategy will safely marshal dots and hyphens (. and -). The passthrough strategy leaves the key as is. Can be used for JMS brokers which do not care whether JMS header keys contain illegal characters. You can provide your own implementation of the org.apache.camel.component.jms.JmsKeyFormatStrategy and refer to it using the notation. |  | JmsKeyFormatStrategy
| *allowAdditionalHeaders* (producer) | This option is used to allow additional headers which may have values that are invalid according to JMS specification. For example some message systems such as WMQ do this with header names using prefix JMS_IBM_MQMD_ containing values with byte array or other invalid types. You can specify multiple header names separated by comma and use as suffix for wildcard matching. |  | String
| *queueBrowseStrategy* (advanced) | To use a custom QueueBrowseStrategy when browsing queues |  | QueueBrowseStrategy
| *messageCreatedStrategy* (advanced) | To use the given MessageCreatedStrategy which are invoked when Camel creates new instances of javax.jms.Message objects when Camel is sending a JMS message. |  | MessageCreatedStrategy
| *waitForProvision CorrelationToBeUpdated Counter* (advanced) | Number of times to wait for provisional correlation id to be updated to the actual correlation id when doing request/reply over JMS and when the option useMessageIDAsCorrelationID is enabled. | 50 | int
| *waitForProvision CorrelationToBeUpdated ThreadSleepingTime* (advanced) | Interval in millis to sleep each time while waiting for provisional correlation id to be updated. | 100 | long
| *correlationProperty* (producer) | Use this JMS property to correlate messages in InOut exchange pattern (request-reply) instead of JMSCorrelationID property. This allows you to exchange messages with systems that do not correlate messages using JMSCorrelationID JMS property. If used JMSCorrelationID will not be used or set by Camel. The value of here named property will be generated if not supplied in the header of the message under the same name. |  | String
| *subscriptionDurable* (consumer) | Set whether to make the subscription durable. The durable subscription name to be used can be specified through the subscriptionName property. Default is false. Set this to true to register a durable subscription typically in combination with a subscriptionName value (unless your message listener class name is good enough as subscription name). Only makes sense when listening to a topic (pub-sub domain) therefore this method switches the pubSubDomain flag as well. | false | boolean
| *subscriptionShared* (consumer) | Set whether to make the subscription shared. The shared subscription name to be used can be specified through the subscriptionName property. Default is false. Set this to true to register a shared subscription typically in combination with a subscriptionName value (unless your message listener class name is good enough as subscription name). Note that shared subscriptions may also be durable so this flag can (and often will) be combined with subscriptionDurable as well. Only makes sense when listening to a topic (pub-sub domain) therefore this method switches the pubSubDomain flag as well. Requires a JMS 2.0 compatible message broker. | false | boolean
| *subscriptionName* (consumer) | Set the name of a subscription to create. To be applied in case of a topic (pub-sub domain) with a shared or durable subscription. The subscription name needs to be unique within this client's JMS client id. Default is the class name of the specified message listener. Note: Only 1 concurrent consumer (which is the default of this message listener container) is allowed for each subscription except for a shared subscription (which requires JMS 2.0). |  | String
| *streamMessageType Enabled* (producer) | Sets whether StreamMessage type is enabled or not. Message payloads of streaming kind such as files InputStream etc will either by sent as BytesMessage or StreamMessage. This option controls which kind will be used. By default BytesMessage is used which enforces the entire message payload to be read into memory. By enabling this option the message payload is read into memory in chunks and each chunk is then written to the StreamMessage until no more data. | false | boolean
| *headerFilterStrategy* (filter) | To use a custom org.apache.camel.spi.HeaderFilterStrategy to filter header to and from Camel message. |  | HeaderFilterStrategy
| *resolveProperty Placeholders* (advanced) | Whether the component should resolve property placeholders on itself when starting. Only properties which are of String type can use property placeholders. | true | boolean
|===
// component options: END







// endpoint options: START
The AMQP endpoint is configured using URI syntax:

----
amqp:destinationType:destinationName
----

with the following path and query parameters:

==== Path Parameters (2 parameters):

[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *destinationType* | The kind of destination to use | queue | String
| *destinationName* | *Required* Name of the queue or topic to use as destination |  | String
|===

==== Query Parameters (90 parameters):

[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *clientId* (common) | Sets the JMS client ID to use. Note that this value if specified must be unique and can only be used by a single JMS connection instance. It is typically only required for durable topic subscriptions. If using Apache ActiveMQ you may prefer to use Virtual Topics instead. |  | String
| *connectionFactory* (common) | The connection factory to be use. A connection factory must be configured either on the component or endpoint. |  | ConnectionFactory
| *disableReplyTo* (common) | Specifies whether Camel ignores the JMSReplyTo header in messages. If true Camel does not send a reply back to the destination specified in the JMSReplyTo header. You can use this option if you want Camel to consume from a route and you do not want Camel to automatically send back a reply message because another component in your code handles the reply message. You can also use this option if you want to use Camel as a proxy between different message brokers and you want to route message from one system to another. | false | boolean
| *durableSubscriptionName* (common) | The durable subscriber name for specifying durable topic subscriptions. The clientId option must be configured as well. |  | String
| *jmsMessageType* (common) | Allows you to force the use of a specific javax.jms.Message implementation for sending JMS messages. Possible values are: Bytes Map Object Stream Text. By default Camel would determine which JMS message type to use from the In body type. This option allows you to specify it. |  | JmsMessageType
| *testConnectionOnStartup* (common) | Specifies whether to test the connection on startup. This ensures that when Camel starts that all the JMS consumers have a valid connection to the JMS broker. If a connection cannot be granted then Camel throws an exception on startup. This ensures that Camel is not started with failed connections. The JMS producers is tested as well. | false | boolean
| *acknowledgementModeName* (consumer) | The JMS acknowledgement name which is one of: SESSION_TRANSACTED CLIENT_ACKNOWLEDGE AUTO_ACKNOWLEDGE DUPS_OK_ACKNOWLEDGE | AUTO_ ACKNOWLEDGE | String
| *asyncConsumer* (consumer) | Whether the JmsConsumer processes the Exchange asynchronously. If enabled then the JmsConsumer may pickup the next message from the JMS queue while the previous message is being processed asynchronously (by the Asynchronous Routing Engine). This means that messages may be processed not 100 strictly in order. If disabled (as default) then the Exchange is fully processed before the JmsConsumer will pickup the next message from the JMS queue. Note if transacted has been enabled then asyncConsumer=true does not run asynchronously as transaction must be executed synchronously (Camel 3.0 may support async transactions). | false | boolean
| *autoStartup* (consumer) | Specifies whether the consumer container should auto-startup. | 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
| *cacheLevel* (consumer) | Sets the cache level by ID for the underlying JMS resources. See cacheLevelName option for more details. |  | int
| *cacheLevelName* (consumer) | Sets the cache level by name for the underlying JMS resources. Possible values are: CACHE_AUTO CACHE_CONNECTION CACHE_CONSUMER CACHE_NONE and CACHE_SESSION. The default setting is CACHE_AUTO. See the Spring documentation and Transactions Cache Levels for more information. | CACHE_AUTO | String
| *concurrentConsumers* (consumer) | Specifies the default number of concurrent consumers when consuming from JMS (not for request/reply over JMS). See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. When doing request/reply over JMS then the option replyToConcurrentConsumers is used to control number of concurrent consumers on the reply message listener. | 1 | int
| *maxConcurrentConsumers* (consumer) | Specifies the maximum number of concurrent consumers when consuming from JMS (not for request/reply over JMS). See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. When doing request/reply over JMS then the option replyToMaxConcurrentConsumers is used to control number of concurrent consumers on the reply message listener. |  | int
| *replyTo* (consumer) | Provides an explicit ReplyTo destination which overrides any incoming value of Message.getJMSReplyTo(). |  | String
| *replyToDeliveryPersistent* (consumer) | Specifies whether to use persistent delivery by default for replies. | true | boolean
| *selector* (consumer) | Sets the JMS selector to use |  | String
| *subscriptionDurable* (consumer) | Set whether to make the subscription durable. The durable subscription name to be used can be specified through the subscriptionName property. Default is false. Set this to true to register a durable subscription typically in combination with a subscriptionName value (unless your message listener class name is good enough as subscription name). Only makes sense when listening to a topic (pub-sub domain) therefore this method switches the pubSubDomain flag as well. | false | boolean
| *subscriptionName* (consumer) | Set the name of a subscription to create. To be applied in case of a topic (pub-sub domain) with a shared or durable subscription. The subscription name needs to be unique within this client's JMS client id. Default is the class name of the specified message listener. Note: Only 1 concurrent consumer (which is the default of this message listener container) is allowed for each subscription except for a shared subscription (which requires JMS 2.0). |  | String
| *subscriptionShared* (consumer) | Set whether to make the subscription shared. The shared subscription name to be used can be specified through the subscriptionName property. Default is false. Set this to true to register a shared subscription typically in combination with a subscriptionName value (unless your message listener class name is good enough as subscription name). Note that shared subscriptions may also be durable so this flag can (and often will) be combined with subscriptionDurable as well. Only makes sense when listening to a topic (pub-sub domain) therefore this method switches the pubSubDomain flag as well. Requires a JMS 2.0 compatible message broker. | false | boolean
| *acceptMessagesWhileStopping* (consumer) | Specifies whether the consumer accept messages while it is stopping. You may consider enabling this option if you start and stop JMS routes at runtime while there are still messages enqueued on the queue. If this option is false and you stop the JMS route then messages may be rejected and the JMS broker would have to attempt redeliveries which yet again may be rejected and eventually the message may be moved at a dead letter queue on the JMS broker. To avoid this its recommended to enable this option. | false | boolean
| *allowReplyManagerQuickStop* (consumer) | Whether the DefaultMessageListenerContainer used in the reply managers for request-reply messaging allow the DefaultMessageListenerContainer.runningAllowed flag to quick stop in case JmsConfigurationisAcceptMessagesWhileStopping is enabled and org.apache.camel.CamelContext is currently being stopped. This quick stop ability is enabled by default in the regular JMS consumers but to enable for reply managers you must enable this flag. | false | boolean
| *consumerType* (consumer) | The consumer type to use which can be one of: Simple Default or Custom. The consumer type determines which Spring JMS listener to use. Default will use org.springframework.jms.listener.DefaultMessageListenerContainer Simple will use org.springframework.jms.listener.SimpleMessageListenerContainer. When Custom is specified the MessageListenerContainerFactory defined by the messageListenerContainerFactory option will determine what org.springframework.jms.listener.AbstractMessageListenerContainer to use. | Default | ConsumerType
| *defaultTaskExecutorType* (consumer) | Specifies what default TaskExecutor type to use in the DefaultMessageListenerContainer for both consumer endpoints and the ReplyTo consumer of producer endpoints. Possible values: SimpleAsync (uses Spring's SimpleAsyncTaskExecutor) or ThreadPool (uses Spring's ThreadPoolTaskExecutor with optimal values - cached threadpool-like). If not set it defaults to the previous behaviour which uses a cached thread pool for consumer endpoints and SimpleAsync for reply consumers. The use of ThreadPool is recommended to reduce thread trash in elastic configurations with dynamically increasing and decreasing concurrent consumers. |  | DefaultTaskExecutor Type
| *eagerLoadingOfProperties* (consumer) | Enables eager loading of JMS properties as soon as a message is loaded which generally is inefficient as the JMS properties may not be required but sometimes can catch early any issues with the underlying JMS provider and the use of JMS properties | false | boolean
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this options 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
| *exposeListenerSession* (consumer) | Specifies whether the listener session should be exposed when consuming messages. | false | boolean
| *replyToSameDestination Allowed* (consumer) | Whether a JMS consumer is allowed to send a reply message to the same destination that the consumer is using to consume from. This prevents an endless loop by consuming and sending back the same message to itself. | false | boolean
| *taskExecutor* (consumer) | Allows you to specify a custom task executor for consuming messages. |  | TaskExecutor
| *deliveryMode* (producer) | Specifies the delivery mode to be used. Possibles values are those defined by javax.jms.DeliveryMode. NON_PERSISTENT = 1 and PERSISTENT = 2. |  | Integer
| *deliveryPersistent* (producer) | Specifies whether persistent delivery is used by default. | true | boolean
| *explicitQosEnabled* (producer) | Set if the deliveryMode priority or timeToLive qualities of service should be used when sending messages. This option is based on Spring's JmsTemplate. The deliveryMode priority and timeToLive options are applied to the current endpoint. This contrasts with the preserveMessageQos option which operates at message granularity reading QoS properties exclusively from the Camel In message headers. | false | Boolean
| *preserveMessageQos* (producer) | Set to true if you want to send message using the QoS settings specified on the message instead of the QoS settings on the JMS endpoint. The following three headers are considered JMSPriority JMSDeliveryMode and JMSExpiration. You can provide all or only some of them. If not provided Camel will fall back to use the values from the endpoint instead. So when using this option the headers override the values from the endpoint. The explicitQosEnabled option by contrast will only use options set on the endpoint and not values from the message header. | false | boolean
| *priority* (producer) | Values greater than 1 specify the message priority when sending (where 0 is the lowest priority and 9 is the highest). The explicitQosEnabled option must also be enabled in order for this option to have any effect. | 4 | int
| *replyToConcurrentConsumers* (producer) | Specifies the default number of concurrent consumers when doing request/reply over JMS. See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. | 1 | int
| *replyToMaxConcurrent Consumers* (producer) | Specifies the maximum number of concurrent consumers when using request/reply over JMS. See also the maxMessagesPerTask option to control dynamic scaling up/down of threads. |  | int
| *replyToOnTimeoutMax ConcurrentConsumers* (producer) | Specifies the maximum number of concurrent consumers for continue routing when timeout occurred when using request/reply over JMS. | 1 | int
| *replyToOverride* (producer) | Provides an explicit ReplyTo destination in the JMS message which overrides the setting of replyTo. It is useful if you want to forward the message to a remote Queue and receive the reply message from the ReplyTo destination. |  | String
| *replyToType* (producer) | Allows for explicitly specifying which kind of strategy to use for replyTo queues when doing request/reply over JMS. Possible values are: Temporary Shared or Exclusive. By default Camel will use temporary queues. However if replyTo has been configured then Shared is used by default. This option allows you to use exclusive queues instead of shared ones. See Camel JMS documentation for more details and especially the notes about the implications if running in a clustered environment and the fact that Shared reply queues has lower performance than its alternatives Temporary and Exclusive. |  | ReplyToType
| *requestTimeout* (producer) | The timeout for waiting for a reply when using the InOut Exchange Pattern (in milliseconds). The default is 20 seconds. You can include the header CamelJmsRequestTimeout to override this endpoint configured timeout value and thus have per message individual timeout values. See also the requestTimeoutCheckerInterval option. | 20000 | long
| *timeToLive* (producer) | When sending messages specifies the time-to-live of the message (in milliseconds). | -1 | long
| *allowAdditionalHeaders* (producer) | This option is used to allow additional headers which may have values that are invalid according to JMS specification. For example some message systems such as WMQ do this with header names using prefix JMS_IBM_MQMD_ containing values with byte array or other invalid types. You can specify multiple header names separated by comma and use as suffix for wildcard matching. |  | String
| *allowNullBody* (producer) | Whether to allow sending messages with no body. If this option is false and the message body is null then an JMSException is thrown. | true | boolean
| *alwaysCopyMessage* (producer) | If true Camel will always make a JMS message copy of the message when it is passed to the producer for sending. Copying the message is needed in some situations such as when a replyToDestinationSelectorName is set (incidentally Camel will set the alwaysCopyMessage option to true if a replyToDestinationSelectorName is set) | false | boolean
| *correlationProperty* (producer) | When using InOut exchange pattern use this JMS property instead of JMSCorrelationID JMS property to correlate messages. If set messages will be correlated solely on the value of this property JMSCorrelationID property will be ignored and not set by Camel. |  | String
| *disableTimeToLive* (producer) | Use this option to force disabling time to live. For example when you do request/reply over JMS then Camel will by default use the requestTimeout value as time to live on the message being sent. The problem is that the sender and receiver systems have to have their clocks synchronized so they are in sync. This is not always so easy to archive. So you can use disableTimeToLive=true to not set a time to live value on the sent message. Then the message will not expire on the receiver system. See below in section About time to live for more details. | false | boolean
| *forceSendOriginalMessage* (producer) | When using mapJmsMessage=false Camel will create a new JMS message to send to a new JMS destination if you touch the headers (get or set) during the route. Set this option to true to force Camel to send the original JMS message that was received. | false | boolean
| *includeSentJMSMessageID* (producer) | Only applicable when sending to JMS destination using InOnly (eg fire and forget). Enabling this option will enrich the Camel Exchange with the actual JMSMessageID that was used by the JMS client when the message was sent to the JMS destination. | false | boolean
| *replyToCacheLevelName* (producer) | Sets the cache level by name for the reply consumer when doing request/reply over JMS. This option only applies when using fixed reply queues (not temporary). Camel will by default use: CACHE_CONSUMER for exclusive or shared w/ replyToSelectorName. And CACHE_SESSION for shared without replyToSelectorName. Some JMS brokers such as IBM WebSphere may require to set the replyToCacheLevelName=CACHE_NONE to work. Note: If using temporary queues then CACHE_NONE is not allowed and you must use a higher value such as CACHE_CONSUMER or CACHE_SESSION. |  | String
| *replyToDestinationSelector Name* (producer) | Sets the JMS Selector using the fixed name to be used so you can filter out your own replies from the others when using a shared queue (that is if you are not using a temporary reply queue). |  | String
| *streamMessageTypeEnabled* (producer) | Sets whether StreamMessage type is enabled or not. Message payloads of streaming kind such as files InputStream etc will either by sent as BytesMessage or StreamMessage. This option controls which kind will be used. By default BytesMessage is used which enforces the entire message payload to be read into memory. By enabling this option the message payload is read into memory in chunks and each chunk is then written to the StreamMessage until no more data. | false | boolean
| *allowSerializedHeaders* (advanced) | Controls whether or not to include serialized headers. Applies only when transferExchange is true. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *asyncStartListener* (advanced) | Whether to startup the JmsConsumer message listener asynchronously when starting a route. For example if a JmsConsumer cannot get a connection to a remote JMS broker then it may block while retrying and/or failover. This will cause Camel to block while starting routes. By setting this option to true you will let routes startup while the JmsConsumer connects to the JMS broker using a dedicated thread in asynchronous mode. If this option is used then beware that if the connection could not be established then an exception is logged at WARN level and the consumer will not be able to receive messages; You can then restart the route to retry. | false | boolean
| *asyncStopListener* (advanced) | Whether to stop the JmsConsumer message listener asynchronously when stopping a route. | false | boolean
| *destinationResolver* (advanced) | A pluggable org.springframework.jms.support.destination.DestinationResolver that allows you to use your own resolver (for example to lookup the real destination in a JNDI registry). |  | DestinationResolver
| *errorHandler* (advanced) | Specifies a org.springframework.util.ErrorHandler to be invoked in case of any uncaught exceptions thrown while processing a Message. By default these exceptions will be logged at the WARN level if no errorHandler has been configured. You can configure logging level and whether stack traces should be logged using errorHandlerLoggingLevel and errorHandlerLogStackTrace options. This makes it much easier to configure than having to code a custom errorHandler. |  | ErrorHandler
| *exceptionListener* (advanced) | Specifies the JMS Exception Listener that is to be notified of any underlying JMS exceptions. |  | ExceptionListener
| *headerFilterStrategy* (advanced) | To use a custom HeaderFilterStrategy to filter header to and from Camel message. |  | HeaderFilterStrategy
| *idleConsumerLimit* (advanced) | Specify the limit for the number of consumers that are allowed to be idle at any given time. | 1 | int
| *idleTaskExecutionLimit* (advanced) | Specifies the limit for idle executions of a receive task not having received any message within its execution. If this limit is reached the task will shut down and leave receiving to other executing tasks (in the case of dynamic scheduling; see the maxConcurrentConsumers setting). There is additional doc available from Spring. | 1 | int
| *includeAllJMSXProperties* (advanced) | Whether to include all JMSXxxx properties when mapping from JMS to Camel Message. Setting this to true will include properties such as JMSXAppID and JMSXUserID etc. Note: If you are using a custom headerFilterStrategy then this option does not apply. | false | boolean
| *jmsKeyFormatStrategy* (advanced) | Pluggable strategy for encoding and decoding JMS keys so they can be compliant with the JMS specification. Camel provides two implementations out of the box: default and passthrough. The default strategy will safely marshal dots and hyphens (. and -). The passthrough strategy leaves the key as is. Can be used for JMS brokers which do not care whether JMS header keys contain illegal characters. You can provide your own implementation of the org.apache.camel.component.jms.JmsKeyFormatStrategy and refer to it using the notation. |  | String
| *mapJmsMessage* (advanced) | Specifies whether Camel should auto map the received JMS message to a suited payload type such as javax.jms.TextMessage to a String etc. | true | boolean
| *maxMessagesPerTask* (advanced) | The number of messages per task. -1 is unlimited. If you use a range for concurrent consumers (eg min max) then this option can be used to set a value to eg 100 to control how fast the consumers will shrink when less work is required. | -1 | int
| *messageConverter* (advanced) | To use a custom Spring org.springframework.jms.support.converter.MessageConverter so you can be in control how to map to/from a javax.jms.Message. |  | MessageConverter
| *messageCreatedStrategy* (advanced) | To use the given MessageCreatedStrategy which are invoked when Camel creates new instances of javax.jms.Message objects when Camel is sending a JMS message. |  | MessageCreatedStrategy
| *messageIdEnabled* (advanced) | When sending specifies whether message IDs should be added. This is just an hint to the JMS broker.If the JMS provider accepts this hint these messages must have the message ID set to null; if the provider ignores the hint the message ID must be set to its normal unique value | true | boolean
| *messageListenerContainer Factory* (advanced) | Registry ID of the MessageListenerContainerFactory used to determine what org.springframework.jms.listener.AbstractMessageListenerContainer to use to consume messages. Setting this will automatically set consumerType to Custom. |  | MessageListener ContainerFactory
| *messageTimestampEnabled* (advanced) | Specifies whether timestamps should be enabled by default on sending messages. This is just an hint to the JMS broker.If the JMS provider accepts this hint these messages must have the timestamp set to zero; if the provider ignores the hint the timestamp must be set to its normal value | true | boolean
| *pubSubNoLocal* (advanced) | Specifies whether to inhibit the delivery of messages published by its own connection. | false | boolean
| *receiveTimeout* (advanced) | The timeout for receiving messages (in milliseconds). | 1000 | long
| *recoveryInterval* (advanced) | Specifies the interval between recovery attempts i.e. when a connection is being refreshed in milliseconds. The default is 5000 ms that is 5 seconds. | 5000 | long
| *requestTimeoutChecker Interval* (advanced) | Configures how often Camel should check for timed out Exchanges when doing request/reply over JMS. By default Camel checks once per second. But if you must react faster when a timeout occurs then you can lower this interval to check more frequently. The timeout is determined by the option requestTimeout. | 1000 | long
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used or Camel is allowed to use asynchronous processing (if supported). | false | boolean
| *transferException* (advanced) | If enabled and you are using Request Reply messaging (InOut) and an Exchange failed on the consumer side then the caused Exception will be send back in response as a javax.jms.ObjectMessage. If the client is Camel the returned Exception is rethrown. This allows you to use Camel JMS as a bridge in your routing - for example using persistent queues to enable robust routing. Notice that if you also have transferExchange enabled this option takes precedence. The caught exception is required to be serializable. The original Exception on the consumer side can be wrapped in an outer exception such as org.apache.camel.RuntimeCamelException when returned to the producer. | false | boolean
| *transferExchange* (advanced) | You can transfer the exchange over the wire instead of just the body and headers. 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. You must enable this option on both the producer and consumer side so Camel knows the payloads is an Exchange and not a regular payload. | false | boolean
| *transferFault* (advanced) | If enabled and you are using Request Reply messaging (InOut) and an Exchange failed with a SOAP fault (not exception) on the consumer side then the fault flag on MessageisFault() will be send back in the response as a JMS header with the key org.apache.camel.component.jms.JmsConstantsJMS_TRANSFER_FAULTJMS_TRANSFER_FAULT. If the client is Camel the returned fault flag will be set on the link org.apache.camel.MessagesetFault(boolean). You may want to enable this when using Camel components that support faults such as SOAP based such as cxf or spring-ws. | false | boolean
| *useMessageIDAsCorrelation ID* (advanced) | Specifies whether JMSMessageID should always be used as JMSCorrelationID for InOut messages. | false | boolean
| *waitForProvisionCorrelation ToBeUpdatedCounter* (advanced) | Number of times to wait for provisional correlation id to be updated to the actual correlation id when doing request/reply over JMS and when the option useMessageIDAsCorrelationID is enabled. | 50 | int
| *waitForProvisionCorrelation ToBeUpdatedThreadSleeping Time* (advanced) | Interval in millis to sleep each time while waiting for provisional correlation id to be updated. | 100 | long
| *errorHandlerLoggingLevel* (logging) | Allows to configure the default errorHandler logging level for logging uncaught exceptions. | WARN | LoggingLevel
| *errorHandlerLogStackTrace* (logging) | Allows to control whether stacktraces should be logged or not by the default errorHandler. | true | boolean
| *password* (security) | Password to use with the ConnectionFactory. You can also configure username/password directly on the ConnectionFactory. |  | String
| *username* (security) | Username to use with the ConnectionFactory. You can also configure username/password directly on the ConnectionFactory. |  | String
| *transacted* (transaction) | Specifies whether to use transacted mode | false | boolean
| *lazyCreateTransaction Manager* (transaction) | If true Camel will create a JmsTransactionManager if there is no transactionManager injected when option transacted=true. | true | boolean
| *transactionManager* (transaction) | The Spring transaction manager to use. |  | PlatformTransaction Manager
| *transactionName* (transaction) | The name of the transaction to use. |  | String
| *transactionTimeout* (transaction) | The timeout value of the transaction (in seconds) if using transacted mode. | -1 | int
|===
// endpoint options: END




### Usage

As AMQP component is inherited from JMS component, the usage of the
former is almost identical to the latter:

*Using AMQP component*

[source,java]
------------------------------------
// Consuming from AMQP queue
from(""amqp:queue:incoming"").
  to(...);
 
// Sending message to the AMQP topic
from(...).
  to(""amqp:topic:notify"");
------------------------------------

### Configuring AMQP component

Starting from the Camel 2.16.1 you can also use the
`AMQPComponent#amqp10Component(String connectionURI)` factory method to
return the AMQP 1.0 component with the pre-configured topic prefix: 

*Creating AMQP 1.0 component*

[source,java]
-----------------------------------------------------------------------------------------
 AMQPComponent amqp = AMQPComponent.amqp10Component(""amqp://guest:guest@localhost:5672"");
-----------------------------------------------------------------------------------------

Keep in mind that starting from the
Camel 2.17 the `AMQPComponent#amqp10Component(String connectionURI)` factory
method has been deprecated on the behalf of the
`AMQPComponent#amqpComponent(String connectionURI)`: 

*Creating AMQP 1.0 component*

[source,java]
--------------------------------------------------------------------------------------------------------
AMQPComponent amqp = AMQPComponent.amqpComponent(""amqp://localhost:5672"");
 
AMQPComponent authorizedAmqp = AMQPComponent.amqpComponent(""amqp://localhost:5672"", ""user"", ""password"");
--------------------------------------------------------------------------------------------------------

Starting from Camel 2.17, in order to automatically configure the AMQP
component, you can also add an instance
of `org.apache.camel.component.amqp.AMQPConnectionDetails` to the
registry. For example for Spring Boot you just have to define bean:

*AMQP connection details auto-configuration*

[source,java]
-------------------------------------------------------------------------------------
@Bean
AMQPConnectionDetails amqpConnection() {
  return new AMQPConnectionDetails(""amqp://localhost:5672""); 
}
 
@Bean
AMQPConnectionDetails securedAmqpConnection() {
  return new AMQPConnectionDetails(""amqp://lcoalhost:5672"", ""username"", ""password""); 
}
-------------------------------------------------------------------------------------

Likewise, you can also use CDI producer methods when using Camel-CDI

*AMQP connection details auto-configuration for CDI*

[source,java]
-------------------------------------------------------------------------------------
@Produces
AMQPConnectionDetails amqpConnection() {
  return new AMQPConnectionDetails(""amqp://localhost:5672"");
}
------------------------------------------------------------------------------------- 

You can also rely on the link:properties.html[Camel properties] to read
the AMQP connection details. Factory
method `AMQPConnectionDetails.discoverAMQP()` attempts to read Camel
properties in a Kubernetes-like convention, just as demonstrated on the
snippet below:

 

*AMQP connection details auto-configuration*

[source,java]
-----------------------------------------------
export AMQP_SERVICE_HOST = ""mybroker.com""
export AMQP_SERVICE_PORT = ""6666""
export AMQP_SERVICE_USERNAME = ""username""
export AMQP_SERVICE_PASSWORD = ""password""
 
...
 
@Bean
AMQPConnectionDetails amqpConnection() {
  return AMQPConnectionDetails.discoverAMQP(); 
}
-----------------------------------------------

### Using topics

To have using topics working with `camel-amqp` you need to configure the
component to use `topic://` as topic prefix, as shown below:

[source,java]
-------------------------------------------------------------------------------------------------------------------------------
 <bean id=""amqp"" class=""org.apache.camel.component.amqp.AmqpComponent"">
   <property name=""connectionFactory"">
     <bean class=""org.apache.qpid.jms.JmsConnectionFactory"" factory-method=""createFromURL"">
       <property name=""remoteURI"" value=""amqp://localhost:5672"" />
       <property name=""topicPrefix"" value=""topic://"" />  <!-- only necessary when connecting to ActiveMQ over AMQP 1.0 -->
     </bean>
   </property>
 </bean>
-------------------------------------------------------------------------------------------------------------------------------

Keep in mind that both  `AMQPComponent#amqpComponent()` methods and
`AMQPConnectionDetails` pre-configure the component with the topic
prefix, so you don't have to configure it explicitly.

### See Also

* link:configuring-camel.html[Configuring Camel]
* link:component.html[Component]
* link:endpoint.html[Endpoint]
* link:getting-started.html[Getting Started]
",12508,True,2969.1744251349864,median
"/******************************************************************************
 *
 * Project:  PDF driver
 * Purpose:  GDALDataset driver for PDF dataset.
 * Author:   Even Rouault, <even dot rouault at spatialys.com>
 *
 ******************************************************************************
 *
 * Support for open-source PDFium library
 *
 * Copyright (C) 2015 Klokan Technologies GmbH (http://www.klokantech.com/)
 * Author: Martin Mikita <martin.mikita@klokantech.com>, xmikit00 @ FIT VUT Brno
 *
 ******************************************************************************
 * Copyright (c) 2011-2013, Even Rouault <even dot rouault at spatialys.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the ""Software""),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 ****************************************************************************/

#include ""gdal_pdf.h""

#include <vector>
#include ""pdfobject.h""

CPL_CVSID(""$Id$"")

/************************************************************************/
/*                        ROUND_TO_INT_IF_CLOSE()                       */
/************************************************************************/

double ROUND_TO_INT_IF_CLOSE(double x, double eps)
{
    if( eps == 0.0 )
        eps = fabs(x) < 1 ? 1e-10 : 1e-8;
    int nClosestInt = (int)floor(x + 0.5);
    if ( fabs(x - nClosestInt) < eps )
        return nClosestInt;
    else
        return x;
}

/************************************************************************/
/*                         GDALPDFGetPDFString()                        */
/************************************************************************/

static CPLString GDALPDFGetPDFString(const char* pszStr)
{
    GByte* pabyData = (GByte*)pszStr;
    int i;
    GByte ch;
    for(i=0;(ch = pabyData[i]) != '\\0';i++)
    {
        if (ch < 32 || ch > 127 ||
            ch == '(' || ch == ')' ||
            ch == '\\\\' || ch == '%' || ch == '#')
            break;
    }
    CPLString osStr;
    if (ch == 0)
    {
        osStr = ""("";
        osStr += pszStr;
        osStr += "")"";
        return osStr;
    }

    wchar_t* pwszDest = CPLRecodeToWChar( pszStr, CPL_ENC_UTF8, CPL_ENC_UCS2 );
    osStr = ""<FEFF"";
    for(i=0;pwszDest[i] != 0;i++)
    {
#ifndef _WIN32
        if (pwszDest[i] >= 0x10000 /* && pwszDest[i] <= 0x10FFFF */)
        {
            /* Generate UTF-16 surrogate pairs (on Windows, CPLRecodeToWChar does it for us)  */
            int nHeadSurrogate = ((pwszDest[i] - 0x10000) >> 10) | 0xd800;
            int nTrailSurrogate = ((pwszDest[i] - 0x10000) & 0x3ff) | 0xdc00;
            osStr += CPLSPrintf(""%02X"", (nHeadSurrogate >> 8) & 0xff);
            osStr += CPLSPrintf(""%02X"", (nHeadSurrogate) & 0xff);
            osStr += CPLSPrintf(""%02X"", (nTrailSurrogate >> 8) & 0xff);
            osStr += CPLSPrintf(""%02X"", (nTrailSurrogate) & 0xff);
        }
        else
#endif
        {
            osStr += CPLSPrintf(""%02X"", (int)(pwszDest[i] >> 8) & 0xff);
            osStr += CPLSPrintf(""%02X"", (int)(pwszDest[i]) & 0xff);
        }
    }
    osStr += "">"";
    CPLFree(pwszDest);
    return osStr;
}

#if defined(HAVE_POPPLER) || defined(HAVE_PDFIUM)

/************************************************************************/
/*                     GDALPDFGetUTF8StringFromBytes()                  */
/************************************************************************/

static CPLString GDALPDFGetUTF8StringFromBytes(const GByte* pabySrc, int nLen)
{
    int bLEUnicodeMarker = nLen > 2 && pabySrc[0] == 0xFE && pabySrc[1] == 0xFF;
    int bBEUnicodeMarker = nLen > 2 && pabySrc[0] == 0xFF && pabySrc[1] == 0xFE;
    if (!bLEUnicodeMarker && !bBEUnicodeMarker)
    {
        CPLString osStr;
        osStr.resize( nLen + 1 );
        osStr.assign( (const char*)pabySrc, (size_t)nLen );
        osStr[nLen] = 0;
        const char* pszStr = osStr.c_str();
        if (CPLIsUTF8(pszStr, -1))
            return osStr;
        else
        {
            char* pszUTF8 = CPLRecode( pszStr, CPL_ENC_ISO8859_1, CPL_ENC_UTF8 );
            CPLString osRet = pszUTF8;
            CPLFree(pszUTF8);
            return osRet;
        }
    }

    /* This is UTF-16 content */
    pabySrc += 2;
    nLen = (nLen - 2) / 2;
    wchar_t *pwszSource = new wchar_t[nLen + 1];
    int j = 0;
    for(int i=0; i<nLen; i++, j++)
    {
        if (!bBEUnicodeMarker)
            pwszSource[j] = (pabySrc[2 * i] << 8) + pabySrc[2 * i + 1];
        else
            pwszSource[j] = (pabySrc[2 * i + 1] << 8) + pabySrc[2 * i];
#ifndef _WIN32
        /* Is there a surrogate pair ? See http://en.wikipedia.org/wiki/UTF-16 */
        /* On Windows, CPLRecodeFromWChar does this for us, because wchar_t is only */
        /* 2 bytes wide, whereas on Unix it is 32bits */
        if (pwszSource[j] >= 0xD800 && pwszSource[j] <= 0xDBFF && i + 1 < nLen)
        {
            /* should be in the range 0xDC00... 0xDFFF */
            wchar_t nTrailSurrogate;
            if (!bBEUnicodeMarker)
                nTrailSurrogate = (pabySrc[2 * (i+1)] << 8) + pabySrc[2 * (i+1) + 1];
            else
                nTrailSurrogate = (pabySrc[2 * (i+1) + 1] << 8) + pabySrc[2 * (i+1)];
            if (nTrailSurrogate >= 0xDC00 && nTrailSurrogate <= 0xDFFF)
            {
                pwszSource[j] = ((pwszSource[j] - 0xD800) << 10) + (nTrailSurrogate - 0xDC00) + 0x10000;
                i++;
            }
        }
#endif
    }
    pwszSource[j] = 0;

    char* pszUTF8 = CPLRecodeFromWChar( pwszSource, CPL_ENC_UCS2, CPL_ENC_UTF8 );
    delete[] pwszSource;
    CPLString osStrUTF8(pszUTF8);
    CPLFree(pszUTF8);
    return osStrUTF8;
}

#endif // defined(HAVE_POPPLER) || defined(HAVE_PDFIUM)

/************************************************************************/
/*                          GDALPDFGetPDFName()                         */
/************************************************************************/

static CPLString GDALPDFGetPDFName(const char* pszStr)
{
    GByte* pabyData = (GByte*)pszStr;
    int i;
    GByte ch;
    CPLString osStr;
    for(i=0;(ch = pabyData[i]) != '\\0';i++)
    {
        if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '-'))
            osStr += '_';
        else
            osStr += ch;
    }
    return osStr;
}

/************************************************************************/
/* ==================================================================== */
/*                            GDALPDFObject                             */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                            ~GDALPDFObject()                          */
/************************************************************************/

GDALPDFObject::~GDALPDFObject()
{
}

/************************************************************************/
/*                            LookupObject()                            */
/************************************************************************/

GDALPDFObject* GDALPDFObject::LookupObject(const char* pszPath)
{
    if( GetType() != PDFObjectType_Dictionary )
        return nullptr;
    return GetDictionary()->LookupObject(pszPath);
}

/************************************************************************/
/*                             GetTypeName()                            */
/************************************************************************/

const char* GDALPDFObject::GetTypeName()
{
    switch(GetType())
    {
        case PDFObjectType_Unknown: return GetTypeNameNative();
        case PDFObjectType_Null: return ""null"";
        case PDFObjectType_Bool: return ""bool"";
        case PDFObjectType_Int: return ""int"";
        case PDFObjectType_Real: return ""real"";
        case PDFObjectType_String: return ""string"";
        case PDFObjectType_Name: return ""name"";
        case PDFObjectType_Array: return ""array"";
        case PDFObjectType_Dictionary: return ""dictionary"";
        default: return GetTypeNameNative();
    }
}

/************************************************************************/
/*                             Serialize()                              */
/************************************************************************/

void GDALPDFObject::Serialize(CPLString& osStr, bool bEmitRef)
{
    auto nRefNum = GetRefNum();
    if( bEmitRef && nRefNum.toBool() )
    {
        int nRefGen = GetRefGen();
        osStr.append(CPLSPrintf(""%d %d R"", nRefNum.toInt(), nRefGen));
        return;
    }

    switch(GetType())
    {
        case PDFObjectType_Null: osStr.append(""null""); return;
        case PDFObjectType_Bool: osStr.append(GetBool() ? ""true"": ""false""); return;
        case PDFObjectType_Int: osStr.append(CPLSPrintf(""%d"", GetInt())); return;
        case PDFObjectType_Real:
        {
            char szReal[512];
            double dfRealNonRounded = GetReal();
            double dfReal = ROUND_TO_INT_IF_CLOSE(dfRealNonRounded);
            if (dfReal == (double)(GIntBig)dfReal)
                snprintf(szReal, sizeof(szReal), CPL_FRMT_GIB, (GIntBig)dfReal);
            else if (CanRepresentRealAsString())
            {
                /* Used for OGC BP numeric values */
                CPLsnprintf(szReal, sizeof(szReal), ""(%.*g)"", GetPrecision(), dfReal);
            }
            else
            {
                CPLsnprintf(szReal, sizeof(szReal), ""%.*f"", GetPrecision(), dfReal);

                /* Remove non significant trailing zeroes */
                char* pszDot = strchr(szReal, '.');
                if (pszDot)
                {
                    int iDot = (int)(pszDot - szReal);
                    int nLen = (int)strlen(szReal);
                    for(int i=nLen-1; i > iDot; i --)
                    {
                        if (szReal[i] == '0')
                            szReal[i] = '\\0';
                        else
                            break;
                    }
                }
            }
            osStr.append(szReal);
            return;
        }
        case PDFObjectType_String: osStr.append(GDALPDFGetPDFString(GetString())); return;
        case PDFObjectType_Name: osStr.append(""/""); osStr.append(GDALPDFGetPDFName(GetName())); return;
        case PDFObjectType_Array: GetArray()->Serialize(osStr); return;
        case PDFObjectType_Dictionary: GetDictionary()->Serialize(osStr); return;
        case PDFObjectType_Unknown:
        default: CPLError(CE_Warning, CPLE_AppDefined,
                          ""Serializing unknown object !""); return;
    }
}

/************************************************************************/
/*                               Clone()                                */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObject::Clone()
{
    auto nRefNum = GetRefNum();
    if( nRefNum.toBool() )
    {
        int nRefGen = GetRefGen();
        return GDALPDFObjectRW::CreateIndirect(nRefNum, nRefGen);
    }

    switch(GetType())
    {
        case PDFObjectType_Null: return GDALPDFObjectRW::CreateNull();
        case PDFObjectType_Bool: return GDALPDFObjectRW::CreateBool(GetBool());
        case PDFObjectType_Int: return GDALPDFObjectRW::CreateInt(GetInt());
        case PDFObjectType_Real: return GDALPDFObjectRW::CreateReal(GetReal());
        case PDFObjectType_String: return GDALPDFObjectRW::CreateString(GetString());
        case PDFObjectType_Name: return GDALPDFObjectRW::CreateName(GetName());
        case PDFObjectType_Array: return GDALPDFObjectRW::CreateArray(GetArray()->Clone());
        case PDFObjectType_Dictionary: return GDALPDFObjectRW::CreateDictionary(GetDictionary()->Clone());
        case PDFObjectType_Unknown:
        default: CPLError(CE_Warning, CPLE_AppDefined,
                          ""Cloning unknown object !""); return nullptr;
    }
}

/************************************************************************/
/* ==================================================================== */
/*                         GDALPDFDictionary                            */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                        ~GDALPDFDictionary()                          */
/************************************************************************/

GDALPDFDictionary::~GDALPDFDictionary()
{
}

/************************************************************************/
/*                            LookupObject()                            */
/************************************************************************/

GDALPDFObject* GDALPDFDictionary::LookupObject(const char* pszPath)
{
    GDALPDFObject* poCurObj = nullptr;
    char** papszTokens = CSLTokenizeString2(pszPath, ""."", 0);
    for(int i=0; papszTokens[i] != nullptr; i++)
    {
        int iElt = -1;
        char* pszBracket = strchr(papszTokens[i], '[');
        if( pszBracket != nullptr )
        {
            iElt = atoi(pszBracket + 1);
            *pszBracket = '\\0';
        }

        if( i == 0 )
        {
            poCurObj = Get(papszTokens[i]);
        }
        else
        {
            if( poCurObj->GetType() != PDFObjectType_Dictionary )
            {
                poCurObj = nullptr;
                break;
            }
            poCurObj = poCurObj->GetDictionary()->Get(papszTokens[i]);
        }

        if( poCurObj == nullptr )
        {
            poCurObj = nullptr;
            break;
        }

        if( iElt >= 0 )
        {
            if( poCurObj->GetType() != PDFObjectType_Array )
            {
                poCurObj = nullptr;
                break;
            }
            poCurObj = poCurObj->GetArray()->Get(iElt);
        }
    }
    CSLDestroy(papszTokens);
    return poCurObj;
}

/************************************************************************/
/*                             Serialize()                              */
/************************************************************************/

void GDALPDFDictionary::Serialize(CPLString& osStr)
{
    osStr.append(""<< "");
    std::map<CPLString, GDALPDFObject*>& oMap = GetValues();
    std::map<CPLString, GDALPDFObject*>::iterator oIter = oMap.begin();
    std::map<CPLString, GDALPDFObject*>::iterator oEnd = oMap.end();
    for(;oIter != oEnd;++oIter)
    {
        const char* pszKey = oIter->first.c_str();
        GDALPDFObject* poObj = oIter->second;
        osStr.append(""/"");
        osStr.append(pszKey);
        osStr.append("" "");
        poObj->Serialize(osStr);
        osStr.append("" "");
    }
    osStr.append("">>"");
}

/************************************************************************/
/*                               Clone()                                */
/************************************************************************/

GDALPDFDictionaryRW* GDALPDFDictionary::Clone()
{
    GDALPDFDictionaryRW* poDict = new GDALPDFDictionaryRW();
    std::map<CPLString, GDALPDFObject*>& oMap = GetValues();
    std::map<CPLString, GDALPDFObject*>::iterator oIter = oMap.begin();
    std::map<CPLString, GDALPDFObject*>::iterator oEnd = oMap.end();
    for(;oIter != oEnd;++oIter)
    {
        const char* pszKey = oIter->first.c_str();
        GDALPDFObject* poObj = oIter->second;
        poDict->Add(pszKey, poObj->Clone());
    }
    return poDict;
}

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFArray                               */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                           ~GDALPDFArray()                            */
/************************************************************************/

GDALPDFArray::~GDALPDFArray()
{
}

/************************************************************************/
/*                             Serialize()                              */
/************************************************************************/

void GDALPDFArray::Serialize(CPLString& osStr)
{
    int nLength = GetLength();
    int i;

    osStr.append(""[ "");
    for(i=0;i<nLength;i++)
    {
        Get(i)->Serialize(osStr);
        osStr.append("" "");
    }
    osStr.append(""]"");
}

/************************************************************************/
/*                               Clone()                                */
/************************************************************************/

GDALPDFArrayRW* GDALPDFArray::Clone()
{
    GDALPDFArrayRW* poArray = new GDALPDFArrayRW();
    int nLength = GetLength();
    int i;
    for(i=0;i<nLength;i++)
    {
        poArray->Add(Get(i)->Clone());
    }
    return poArray;
}

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFStream                              */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                           ~GDALPDFStream()                           */
/************************************************************************/

GDALPDFStream::~GDALPDFStream()
{
}

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFObjectRW                            */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                           GDALPDFObjectRW()                          */
/************************************************************************/

GDALPDFObjectRW::GDALPDFObjectRW(GDALPDFObjectType eType) :
    m_eType(eType),
    m_nVal(0),
    m_dfVal(0.0),
    // m_osVal
    m_poDict(nullptr),
    m_poArray(nullptr),
    m_nNum(0),
    m_nGen(0),
    m_bCanRepresentRealAsString(FALSE)
{}

/************************************************************************/
/*                             ~GDALPDFObjectRW()                       */
/************************************************************************/

GDALPDFObjectRW::~GDALPDFObjectRW()
{
    delete m_poDict;
    delete m_poArray;
}

/************************************************************************/
/*                            CreateIndirect()                          */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateIndirect(const GDALPDFObjectNum& nNum, int nGen)
{
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Unknown);
    poObj->m_nNum = nNum;
    poObj->m_nGen = nGen;
    return poObj;
}

/************************************************************************/
/*                             CreateNull()                             */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateNull()
{
    return new GDALPDFObjectRW(PDFObjectType_Null);
}

/************************************************************************/
/*                             CreateBool()                             */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateBool(int bVal)
{
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Bool);
    poObj->m_nVal = bVal;
    return poObj;
}

/************************************************************************/
/*                             CreateInt()                              */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateInt(int nVal)
{
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Int);
    poObj->m_nVal = nVal;
    return poObj;
}

/************************************************************************/
/*                            CreateReal()                              */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateReal(double dfVal,
                                             int bCanRepresentRealAsString)
{
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Real);
    poObj->m_dfVal = dfVal;
    poObj->m_bCanRepresentRealAsString = bCanRepresentRealAsString;
    return poObj;
}

/************************************************************************/
/*                       CreateRealWithPrecision()                      */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateRealWithPrecision(double dfVal,
                                             int nPrecision)
{
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Real);
    poObj->m_dfVal = dfVal;
    poObj->m_nPrecision = nPrecision;
    return poObj;
}

/************************************************************************/
/*                           CreateString()                             */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateString(const char* pszStr)
{
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_String);
    poObj->m_osVal = pszStr;
    return poObj;
}

/************************************************************************/
/*                            CreateName()                              */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateName(const char* pszName)
{
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Name);
    poObj->m_osVal = pszName;
    return poObj;
}

/************************************************************************/
/*                          CreateDictionary()                          */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateDictionary(GDALPDFDictionaryRW* poDict)
{
    CPLAssert(poDict);
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Dictionary);
    poObj->m_poDict = poDict;
    return poObj;
}

/************************************************************************/
/*                            CreateArray()                             */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateArray(GDALPDFArrayRW* poArray)
{
    CPLAssert(poArray);
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Array);
    poObj->m_poArray = poArray;
    return poObj;
}

/************************************************************************/
/*                          GetTypeNameNative()                         */
/************************************************************************/

const char* GDALPDFObjectRW::GetTypeNameNative()
{
    CPLError(CE_Failure, CPLE_AppDefined, ""Should not go here"");
    return """";
}

/************************************************************************/
/*                             GetType()                                */
/************************************************************************/

GDALPDFObjectType GDALPDFObjectRW::GetType()
{
    return m_eType;
}

/************************************************************************/
/*                             GetBool()                                */
/************************************************************************/

int GDALPDFObjectRW::GetBool()
{
    if (m_eType == PDFObjectType_Bool)
        return m_nVal;

    return FALSE;
}

/************************************************************************/
/*                               GetInt()                               */
/************************************************************************/

int GDALPDFObjectRW::GetInt()
{
    if (m_eType == PDFObjectType_Int)
        return m_nVal;

    return 0;
}

/************************************************************************/
/*                              GetReal()                               */
/************************************************************************/

double GDALPDFObjectRW::GetReal()
{
   return m_dfVal;
}

/************************************************************************/
/*                             GetString()                              */
/************************************************************************/

const CPLString& GDALPDFObjectRW::GetString()
{
    return m_osVal;
}

/************************************************************************/
/*                              GetName()                               */
/************************************************************************/

const CPLString& GDALPDFObjectRW::GetName()
{
    return m_osVal;
}

/************************************************************************/
/*                            GetDictionary()                           */
/************************************************************************/

GDALPDFDictionary* GDALPDFObjectRW::GetDictionary()
{
    return m_poDict;
}

/************************************************************************/
/*                              GetArray()                              */
/************************************************************************/

GDALPDFArray* GDALPDFObjectRW::GetArray()
{
    return m_poArray;
}

/************************************************************************/
/*                              GetStream()                             */
/************************************************************************/

GDALPDFStream* GDALPDFObjectRW::GetStream()
{
    return nullptr;
}

/************************************************************************/
/*                              GetRefNum()                             */
/************************************************************************/

GDALPDFObjectNum GDALPDFObjectRW::GetRefNum()
{
    return m_nNum;
}

/************************************************************************/
/*                              GetRefGen()                             */
/************************************************************************/

int GDALPDFObjectRW::GetRefGen()
{
    return m_nGen;
}

/************************************************************************/
/* ==================================================================== */
/*                          GDALPDFDictionaryRW                         */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                           GDALPDFDictionaryRW()                      */
/************************************************************************/

GDALPDFDictionaryRW::GDALPDFDictionaryRW() {}

/************************************************************************/
/*                          ~GDALPDFDictionaryRW()                      */
/************************************************************************/

GDALPDFDictionaryRW::~GDALPDFDictionaryRW()
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.begin();
    std::map<CPLString, GDALPDFObject*>::iterator oEnd = m_map.end();
    for(; oIter != oEnd; ++oIter)
        delete oIter->second;
}

/************************************************************************/
/*                                   Get()                              */
/************************************************************************/

GDALPDFObject* GDALPDFDictionaryRW::Get(const char* pszKey)
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.find(pszKey);
    if (oIter != m_map.end())
        return oIter->second;
    return nullptr;
}

/************************************************************************/
/*                               GetValues()                            */
/************************************************************************/

std::map<CPLString, GDALPDFObject*>& GDALPDFDictionaryRW::GetValues()
{
    return m_map;
}

/************************************************************************/
/*                                 Add()                                */
/************************************************************************/

GDALPDFDictionaryRW& GDALPDFDictionaryRW::Add(const char* pszKey, GDALPDFObject* poVal)
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.find(pszKey);
    if (oIter != m_map.end())
    {
        delete oIter->second;
        oIter->second = poVal;
    }
    else
        m_map[pszKey] = poVal;

    return *this;
}

/************************************************************************/
/*                                Remove()                              */
/************************************************************************/

GDALPDFDictionaryRW& GDALPDFDictionaryRW::Remove(const char* pszKey)
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.find(pszKey);
    if (oIter != m_map.end())
    {
        delete oIter->second;
        m_map.erase(pszKey);
    }

    return *this;
}

/************************************************************************/
/* ==================================================================== */
/*                            GDALPDFArrayRW                            */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                             GDALPDFArrayRW()                         */
/************************************************************************/

GDALPDFArrayRW::GDALPDFArrayRW() {}

/************************************************************************/
/*                            ~GDALPDFArrayRW()                         */
/************************************************************************/

GDALPDFArrayRW::~GDALPDFArrayRW()
{
    for( size_t i = 0; i < m_array.size(); i++ )
        delete m_array[i];
}

/************************************************************************/
/*                               GetLength()                             */
/************************************************************************/

int GDALPDFArrayRW::GetLength()
{
    return static_cast<int>(m_array.size());
}

/************************************************************************/
/*                                  Get()                               */
/************************************************************************/

GDALPDFObject* GDALPDFArrayRW::Get(int nIndex)
{
    if (nIndex < 0 || nIndex >= GetLength())
        return nullptr;
    return m_array[nIndex];
}

/************************************************************************/
/*                                  Add()                               */
/************************************************************************/

GDALPDFArrayRW& GDALPDFArrayRW::Add(GDALPDFObject* poObj)
{
    m_array.push_back(poObj);
    return *this;
}

/************************************************************************/
/*                                  Add()                               */
/************************************************************************/

GDALPDFArrayRW& GDALPDFArrayRW::Add(double* padfVal, int nCount,
                                    int bCanRepresentRealAsString)
{
    for(int i=0;i<nCount;i++)
        m_array.push_back(GDALPDFObjectRW::CreateReal(padfVal[i], bCanRepresentRealAsString));
    return *this;
}

#ifdef HAVE_POPPLER

/************************************************************************/
/* ==================================================================== */
/*                         GDALPDFDictionaryPoppler                     */
/* ==================================================================== */
/************************************************************************/

class GDALPDFDictionaryPoppler: public GDALPDFDictionary
{
    private:
        Dict* m_poDict;
        std::map<CPLString, GDALPDFObject*> m_map;

    public:
        GDALPDFDictionaryPoppler(Dict* poDict) : m_poDict(poDict) {}
        virtual ~GDALPDFDictionaryPoppler();

        virtual GDALPDFObject* Get(const char* pszKey) override;
        virtual std::map<CPLString, GDALPDFObject*>& GetValues() override;
};

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFArrayPoppler                        */
/* ==================================================================== */
/************************************************************************/

class GDALPDFArrayPoppler : public GDALPDFArray
{
    private:
        Array* m_poArray;
        std::vector<GDALPDFObject*> m_v;

    public:
        GDALPDFArrayPoppler(Array* poArray) : m_poArray(poArray) {}
        virtual ~GDALPDFArrayPoppler();

        virtual int GetLength() override;
        virtual GDALPDFObject* Get(int nIndex) override;
};

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFStreamPoppler                       */
/* ==================================================================== */
/************************************************************************/

class GDALPDFStreamPoppler : public GDALPDFStream
{
    private:
        int     m_nLength = -1;
        Stream* m_poStream;
        int     m_nRawLength = -1;

    public:
        GDALPDFStreamPoppler(Stream* poStream) : m_poStream(poStream) {}
        virtual ~GDALPDFStreamPoppler() {}

        virtual int GetLength() override;
        virtual char* GetBytes() override;

        virtual int GetRawLength() override;
        virtual char* GetRawBytes() override;
};

/************************************************************************/
/* ==================================================================== */
/*                         GDALPDFObjectPoppler                         */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                          ~GDALPDFObjectPoppler()                     */
/************************************************************************/

GDALPDFObjectPoppler::~GDALPDFObjectPoppler()
{
#if !(POPPLER_MAJOR_VERSION >= 1 || POPPLER_MINOR_VERSION >= 58)
    m_po->free();
#endif
    if (m_bDestroy)
        delete m_po;
    delete m_poDict;
    delete m_poArray;
    delete m_poStream;
}

/************************************************************************/
/*                              GetType()                               */
/************************************************************************/

GDALPDFObjectType GDALPDFObjectPoppler::GetType()
{
    switch(m_po->getType())
    {
        case objNull:       return PDFObjectType_Null;
        case objBool:       return PDFObjectType_Bool;
        case objInt:        return PDFObjectType_Int;
        case objReal:       return PDFObjectType_Real;
        case objString:     return PDFObjectType_String;
        case objName:       return PDFObjectType_Name;
        case objArray:      return PDFObjectType_Array;
        case objDict:       return PDFObjectType_Dictionary;
        case objStream:     return PDFObjectType_Dictionary;
        default:            return PDFObjectType_Unknown;
    }
}

/************************************************************************/
/*                          GetTypeNameNative()                         */
/************************************************************************/

const char* GDALPDFObjectPoppler::GetTypeNameNative()
{
    return m_po->getTypeName();
}

/************************************************************************/
/*                               GetBool()                              */
/************************************************************************/

int GDALPDFObjectPoppler::GetBool()
{
    if (GetType() == PDFObjectType_Bool)
        return m_po->getBool();
    else
        return 0;
}

/************************************************************************/
/*                               GetInt()                               */
/************************************************************************/

int GDALPDFObjectPoppler::GetInt()
{
    if (GetType() == PDFObjectType_Int)
        return m_po->getInt();
    else
        return 0;
}

/************************************************************************/
/*                               GetReal()                              */
/************************************************************************/

double GDALPDFObjectPoppler::GetReal()
{
    if (GetType() == PDFObjectType_Real)
        return m_po->getReal();
    else
        return 0.0;
}

/************************************************************************/
/*                              GetString()                             */
/************************************************************************/

const CPLString& GDALPDFObjectPoppler::GetString()
{
    if (GetType() == PDFObjectType_String)
    {
#if POPPLER_MAJOR_VERSION >= 1 || POPPLER_MINOR_VERSION >= 58
        // At least available since poppler 0.41
        const GooString* gooString = m_po->getString();
#else
        GooString* gooString = m_po->getString();
#endif
#if (POPPLER_MAJOR_VERSION >= 1 || POPPLER_MINOR_VERSION >= 72)
        return (osStr = GDALPDFGetUTF8StringFromBytes(reinterpret_cast<const GByte*>(gooString->c_str()),
                                                      static_cast<int>(gooString->getLength())));
#else
        return (osStr = GDALPDFGetUTF8StringFromBytes(reinterpret_cast<const GByte*>(gooString->getCString()),
                                                      static_cast<int>(gooString->getLength())));
#endif
    }
    else
        return (osStr = """");
}

/************************************************************************/
/*                               GetName()                              */
/************************************************************************/

const CPLString& GDALPDFObjectPoppler::GetName()
{
    if (GetType() == PDFObjectType_Name)
        return (osStr = m_po->getName());
    else
        return (osStr = """");
}

/************************************************************************/
/*                            GetDictionary()                           */
/************************************************************************/

GDALPDFDictionary* GDALPDFObjectPoppler::GetDictionary()
{
    if (GetType() != PDFObjectType_Dictionary)
        return nullptr;

    if (m_poDict)
        return m_poDict;

    Dict* poDict = (m_po->getType() == objStream) ? m_po->getStream()->getDict() : m_po->getDict();
    if (poDict == nullptr)
        return nullptr;
    m_poDict = new GDALPDFDictionaryPoppler(poDict);
    return m_poDict;
}

/************************************************************************/
/*                              GetArray()                              */
/************************************************************************/

GDALPDFArray* GDALPDFObjectPoppler::GetArray()
{
    if (GetType() != PDFObjectType_Array)
        return nullptr;

    if (m_poArray)
        return m_poArray;

    Array* poArray = m_po->getArray();
    if (poArray == nullptr)
        return nullptr;
    m_poArray = new GDALPDFArrayPoppler(poArray);
    return m_poArray;
}

/************************************************************************/
/*                             GetStream()                              */
/************************************************************************/

GDALPDFStream* GDALPDFObjectPoppler::GetStream()
{
    if (m_po->getType() != objStream)
        return nullptr;

    if (m_poStream)
        return m_poStream;
    m_poStream = new GDALPDFStreamPoppler(m_po->getStream());
    return m_poStream;
}

/************************************************************************/
/*                           SetRefNumAndGen()                          */
/************************************************************************/

void GDALPDFObjectPoppler::SetRefNumAndGen(const GDALPDFObjectNum& nNum, int nGen)
{
    m_nRefNum = nNum;
    m_nRefGen = nGen;
}

/************************************************************************/
/*                               GetRefNum()                            */
/************************************************************************/

GDALPDFObjectNum GDALPDFObjectPoppler::GetRefNum()
{
    return m_nRefNum;
}

/************************************************************************/
/*                               GetRefGen()                            */
/************************************************************************/

int GDALPDFObjectPoppler::GetRefGen()
{
    return m_nRefGen;
}

/************************************************************************/
/* ==================================================================== */
/*                        GDALPDFDictionaryPoppler                      */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                       ~GDALPDFDictionaryPoppler()                    */
/************************************************************************/

GDALPDFDictionaryPoppler::~GDALPDFDictionaryPoppler()
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.begin();
    std::map<CPLString, GDALPDFObject*>::iterator oEnd = m_map.end();
    for(; oIter != oEnd; ++oIter)
        delete oIter->second;
}

/************************************************************************/
/*                                  Get()                               */
/************************************************************************/

GDALPDFObject* GDALPDFDictionaryPoppler::Get(const char* pszKey)
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.find(pszKey);
    if (oIter != m_map.end())
        return oIter->second;

#if POPPLER_MAJOR_VERSION >= 1 || POPPLER_MINOR_VERSION >= 58
    auto&& o(m_poDict->lookupNF(((char*)pszKey)));
    if (!o.isNull())
    {
        GDALPDFObjectNum nRefNum;
        int nRefGen = 0;
        if( o.isRef())
        {
            nRefNum = o.getRefNum();
            nRefGen = o.getRefGen();
            Object o2(m_poDict->lookup((char*)pszKey));
            if( !o2.isNull() )
            {
                GDALPDFObjectPoppler* poObj = new GDALPDFObjectPoppler(new Object(std::move(o2)), TRUE);
                poObj->SetRefNumAndGen(nRefNum, nRefGen);
                m_map[pszKey] = poObj;
                return poObj;
            }
        }
        else
        {
            GDALPDFObjectPoppler* poObj = new GDALPDFObjectPoppler(new Object(o.copy()), TRUE);
            poObj->SetRefNumAndGen(nRefNum, nRefGen);
            m_map[pszKey] = poObj;
            return poObj;
        }
    }
    return nullptr;
#else
    Object* po = new Object;
    if (m_poDict->lookupNF((char*)pszKey, po) && !po->isNull())
    {
        GDALPDFObjectNum nRefNum;
        int nRefGen = 0;
        if( po->isRef())
        {
            nRefNum = po->getRefNum();
            nRefGen = po->getRefGen();
        }
        if( !po->isRef() || (m_poDict->lookup((char*)pszKey, po) && !po->isNull()) )
        {
            GDALPDFObjectPoppler* poObj = new GDALPDFObjectPoppler(po, TRUE);
            poObj->SetRefNumAndGen(nRefNum, nRefGen);
            m_map[pszKey] = poObj;
            return poObj;
        }
        else
        {
            delete po;
            return nullptr;
        }
    }
    else
    {
        delete po;
        return nullptr;
    }
#endif
}

/************************************************************************/
/*                                GetValues()                           */
/************************************************************************/

std::map<CPLString, GDALPDFObject*>& GDALPDFDictionaryPoppler::GetValues()
{
    int i = 0;
    int nLength = m_poDict->getLength();
    for(i=0;i<nLength;i++)
    {
        const char* pszKey = (const char*)m_poDict->getKey(i);
        Get(pszKey);
    }
    return m_map;
}

/************************************************************************/
/* ==================================================================== */
/*                          GDALPDFArrayPoppler                         */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                           GDALPDFCreateArray()                       */
/************************************************************************/

GDALPDFArray* GDALPDFCreateArray(Array* array)
{
    return new GDALPDFArrayPoppler(array);
}

/************************************************************************/
/*                           ~GDALPDFArrayPoppler()                     */
/************************************************************************/

GDALPDFArrayPoppler::~GDALPDFArrayPoppler()
{
    for(size_t i=0;i<m_v.size();i++)
    {
        delete m_v[i];
    }
}

/************************************************************************/
/*                               GetLength()                            */
/************************************************************************/

int GDALPDFArrayPoppler::GetLength()
{
    return m_poArray->getLength();
}

/************************************************************************/
/*                                 Get()                                */
/************************************************************************/

GDALPDFObject* GDALPDFArrayPoppler::Get(int nIndex)
{
    if (nIndex < 0 || nIndex >= GetLength())
        return nullptr;

    int nOldSize = static_cast<int>(m_v.size());
    if (nIndex >= nOldSize)
    {
        m_v.resize(nIndex+1);
        for(int i=nOldSize;i<=nIndex;i++)
        {
            m_v[i] = nullptr;
        }
    }

    if (m_v[nIndex] != nullptr)
        return m_v[nIndex];

#if POPPLER_MAJOR_VERSION >= 1 || POPPLER_MINOR_VERSION >= 58
    auto&& o(m_poArray->getNF(nIndex));
    if( !o.isNull() )
    {
        GDALPDFObjectNum nRefNum;
        int nRefGen = 0;
        if( o.isRef())
        {
            nRefNum = o.getRefNum();
            nRefGen = o.getRefGen();
            Object o2(m_poArray->get(nIndex));
            if( !o2.isNull() )
            {
                GDALPDFObjectPoppler* poObj = new GDALPDFObjectPoppler(new Object(std::move(o2)), TRUE);
                poObj->SetRefNumAndGen(nRefNum, nRefGen);
                m_v[nIndex] = poObj;
                return poObj;
            }
        }
        else
        {
            GDALPDFObjectPoppler* poObj = new GDALPDFObjectPoppler(new Object(o.copy()), TRUE);
            poObj->SetRefNumAndGen(nRefNum, nRefGen);
            m_v[nIndex] = poObj;
            return poObj;
        }
    }
    return nullptr;
#else
    Object* po = new Object;
    if (m_poArray->getNF(nIndex, po))
    {
        GDALPDFObjectNum nRefNum;
        int nRefGen = 0;
        if( po->isRef())
        {
            nRefNum = po->getRefNum();
            nRefGen = po->getRefGen();
        }
        if( !po->isRef() || (m_poArray->get(nIndex, po)) )
        {
            GDALPDFObjectPoppler* poObj = new GDALPDFObjectPoppler(po, TRUE);
            poObj->SetRefNumAndGen(nRefNum, nRefGen);
            m_v[nIndex] = poObj;
            return poObj;
        }
        else
        {
            delete po;
            return nullptr;
        }
    }
    else
    {
        delete po;
        return nullptr;
    }
#endif
}

/************************************************************************/
/* ==================================================================== */
/*                          GDALPDFStreamPoppler                        */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                               GetLength()                            */
/************************************************************************/

int GDALPDFStreamPoppler::GetLength()
{
    if (m_nLength >= 0)
        return m_nLength;

    m_poStream->reset();
    m_nLength = 0;
    while(m_poStream->getChar() != EOF)
        m_nLength ++;
    return m_nLength;
}

/************************************************************************/
/*                         GooStringToCharStart()                       */
/************************************************************************/

static char* GooStringToCharStart(GooString& gstr)
{
    auto nLength = gstr.getLength();
    if( nLength )
    {
        char* pszContent = (char*) VSIMalloc(nLength + 1);
        if (pszContent)
        {
#if (POPPLER_MAJOR_VERSION >= 1 || POPPLER_MINOR_VERSION >= 72)
            const char* srcStr = gstr.c_str();
#else
            const char* srcStr = gstr.getCString();
#endif
            memcpy(pszContent, srcStr, nLength);
            pszContent[nLength] = '\\0';
        }
        return pszContent;
    }
    return nullptr;
}

/************************************************************************/
/*                               GetBytes()                             */
/************************************************************************/

char* GDALPDFStreamPoppler::GetBytes()
{
    GooString gstr;
    m_poStream->fillGooString(&gstr);
    m_nLength = gstr.getLength();
    return GooStringToCharStart(gstr);
}

/************************************************************************/
/*                            GetRawLength()                            */
/************************************************************************/

int GDALPDFStreamPoppler::GetRawLength()
{
    if (m_nRawLength >= 0)
        return m_nRawLength;

    auto undecodeStream = m_poStream->getUndecodedStream();
    undecodeStream->reset();
    m_nRawLength = 0;
    while(undecodeStream->getChar() != EOF)
        m_nRawLength ++;
    return m_nRawLength;
}

/************************************************************************/
/*                             GetRawBytes()                            */
/************************************************************************/

char* GDALPDFStreamPoppler::GetRawBytes()
{
    GooString gstr;
    auto undecodeStream = m_poStream->getUndecodedStream();
    undecodeStream->fillGooString(&gstr);
    m_nRawLength = gstr.getLength();
    return GooStringToCharStart(gstr);
}


#endif // HAVE_POPPLER

#ifdef HAVE_PODOFO

/************************************************************************/
/* ==================================================================== */
/*                         GDALPDFDictionaryPodofo                      */
/* ==================================================================== */
/************************************************************************/

class GDALPDFDictionaryPodofo: public GDALPDFDictionary
{
    private:
        PoDoFo::PdfDictionary* m_poDict;
        PoDoFo::PdfVecObjects& m_poObjects;
        std::map<CPLString, GDALPDFObject*> m_map;

    public:
        GDALPDFDictionaryPodofo(PoDoFo::PdfDictionary* poDict, PoDoFo::PdfVecObjects& poObjects) : m_poDict(poDict), m_poObjects(poObjects) {}
        virtual ~GDALPDFDictionaryPodofo();

        virtual GDALPDFObject* Get(const char* pszKey) override;
        virtual std::map<CPLString, GDALPDFObject*>& GetValues() override;
};

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFArrayPodofo                         */
/* ==================================================================== */
/************************************************************************/

class GDALPDFArrayPodofo : public GDALPDFArray
{
    private:
        PoDoFo::PdfArray* m_poArray;
        PoDoFo::PdfVecObjects& m_poObjects;
        std::vector<GDALPDFObject*> m_v;

    public:
        GDALPDFArrayPodofo(PoDoFo::PdfArray* poArray, PoDoFo::PdfVecObjects& poObjects) : m_poArray(poArray), m_poObjects(poObjects) {}
        virtual ~GDALPDFArrayPodofo();

        virtual int GetLength() override;
        virtual GDALPDFObject* Get(int nIndex) override;
};

/************************************************************************/
/* ==================================================================== */
/*                          GDALPDFStreamPodofo                         */
/* ==================================================================== */
/************************************************************************/

class GDALPDFStreamPodofo : public GDALPDFStream
{
    private:
        PoDoFo::PdfStream* m_pStream;

    public:
        GDALPDFStreamPodofo(PoDoFo::PdfStream* pStream) : m_pStream(pStream) { }
        virtual ~GDALPDFStreamPodofo() { }

        virtual int GetLength() override;
        virtual char* GetBytes() override;

        virtual int GetRawLength() override;
        virtual char* GetRawBytes() override;
};

/************************************************************************/
/* ==================================================================== */
/*                          GDALPDFObjectPodofo                         */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                          GDALPDFObjectPodofo()                       */
/************************************************************************/

GDALPDFObjectPodofo::GDALPDFObjectPodofo(PoDoFo::PdfObject* po,
                                         PoDoFo::PdfVecObjects& poObjects) :
    m_po(po),
    m_poObjects(poObjects),
    m_poDict(nullptr),
    m_poArray(nullptr),
    m_poStream(nullptr)
{
    try
    {
        if (m_po->GetDataType() == PoDoFo::ePdfDataType_Reference)
        {
            PoDoFo::PdfObject* poObj = m_poObjects.GetObject(m_po->GetReference());
            if (poObj)
                m_po = poObj;
        }
    }
    catch(PoDoFo::PdfError& oError)
    {
        CPLError(CE_Failure, CPLE_AppDefined, ""Invalid PDF : %s"", oError.what());
    }
}

/************************************************************************/
/*                         ~GDALPDFObjectPodofo()                       */
/************************************************************************/

GDALPDFObjectPodofo::~GDALPDFObjectPodofo()
{
    delete m_poDict;
    delete m_poArray;
    delete m_poStream;
}

/************************************************************************/
/*                               GetType()                              */
/************************************************************************/

GDALPDFObjectType GDALPDFObjectPodofo::GetType()
{
    try
    {
        switch(m_po->GetDataType())
        {
            case PoDoFo::ePdfDataType_Null:       return PDFObjectType_Null;
            case PoDoFo::ePdfDataType_Bool:       return PDFObjectType_Bool;
            case PoDoFo::ePdfDataType_Number:     return PDFObjectType_Int;
            case PoDoFo::ePdfDataType_Real:       return PDFObjectType_Real;
            case PoDoFo::ePdfDataType_HexString:  return PDFObjectType_String;
            case PoDoFo::ePdfDataType_String:     return PDFObjectType_String;
            case PoDoFo::ePdfDataType_Name:       return PDFObjectType_Name;
            case PoDoFo::ePdfDataType_Array:      return PDFObjectType_Array;
            case PoDoFo::ePdfDataType_Dictionary: return PDFObjectType_Dictionary;
            default:                              return PDFObjectType_Unknown;
        }
    }
    catch(PoDoFo::PdfError& oError)
    {
        CPLError(CE_Failure, CPLE_AppDefined, ""Invalid PDF : %s"", oError.what());
        return PDFObjectType_Unknown;
    }
}

/************************************************************************/
/*                          GetTypeNameNative()                         */
/************************************************************************/

const char* GDALPDFObjectPodofo::GetTypeNameNative()
{
    try
    {
        return m_po->GetDataTypeString();
    }
    catch(PoDoFo::PdfError& oError)
    {
        CPLError(CE_Failure, CPLE_AppDefined, ""Invalid PDF : %s"", oError.what());
        return ""unknown"";
    }
}

/************************************************************************/
/*                              GetBool()                               */
/************************************************************************/

int GDALPDFObjectPodofo::GetBool()
{
    if (m_po->GetDataType() == PoDoFo::ePdfDataType_Bool)
        return m_po->GetBool();
    else
        return 0;
}

/************************************************************************/
/*                              GetInt()                                */
/************************************************************************/

int GDALPDFObjectPodofo::GetInt()
{
    if (m_po->GetDataType() == PoDoFo::ePdfDataType_Number)
        return static_cast<int>(m_po->GetNumber());
    else
        return 0;
}

/************************************************************************/
/*                              GetReal()                               */
/************************************************************************/

double GDALPDFObjectPodofo::GetReal()
{
    if (GetType() == PDFObjectType_Real)
        return m_po->GetReal();
    else
        return 0.0;
}

/************************************************************************/
/*                              GetString()                             */
/************************************************************************/

const CPLString& GDALPDFObjectPodofo::GetString()
{
    if (GetType() == PDFObjectType_String)
        return (osStr = m_po->GetString().GetStringUtf8());
    else
        return (osStr = """");
}

/************************************************************************/
/*                              GetName()                               */
/************************************************************************/

const CPLString&  GDALPDFObjectPodofo::GetName()
{
    if (GetType() == PDFObjectType_Name)
        return (osStr = m_po->GetName().GetName());
    else
        return (osStr = """");
}

/************************************************************************/
/*                             GetDictionary()                          */
/************************************************************************/

GDALPDFDictionary* GDALPDFObjectPodofo::GetDictionary()
{
    if (GetType() != PDFObjectType_Dictionary)
        return nullptr;

    if (m_poDict)
        return m_poDict;

    m_poDict = new GDALPDFDictionaryPodofo(&m_po->GetDictionary(), m_poObjects);
    return m_poDict;
}

/************************************************************************/
/*                                GetArray()                            */
/************************************************************************/

GDALPDFArray* GDALPDFObjectPodofo::GetArray()
{
    if (GetType() != PDFObjectType_Array)
        return nullptr;

    if (m_poArray)
        return m_poArray;

    m_poArray = new GDALPDFArrayPodofo(&m_po->GetArray(), m_poObjects);
    return m_poArray;
}

/************************************************************************/
/*                               GetStream()                            */
/************************************************************************/

GDALPDFStream* GDALPDFObjectPodofo::GetStream()
{
    try
    {
        if (!m_po->HasStream())
            return nullptr;
    }
    catch(PoDoFo::PdfError& oError)
    {
        CPLError(CE_Failure, CPLE_AppDefined, ""Invalid object : %s"", oError.what());
        return nullptr;
    }
    catch(...)
    {
        CPLError(CE_Failure, CPLE_AppDefined, ""Invalid object"");
        return nullptr;
    }

    if (m_poStream == nullptr)
        m_poStream = new GDALPDFStreamPodofo(m_po->GetStream());
    return m_poStream;
}

/************************************************************************/
/*                               GetRefNum()                            */
/************************************************************************/

GDALPDFObjectNum GDALPDFObjectPodofo::GetRefNum()
{
    return GDALPDFObjectNum(m_po->Reference().ObjectNumber());
}

/************************************************************************/
/*                               GetRefGen()                            */
/************************************************************************/

int GDALPDFObjectPodofo::GetRefGen()
{
    return m_po->Reference().GenerationNumber();
}

/************************************************************************/
/* ==================================================================== */
/*                         GDALPDFDictionaryPodofo                      */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                         ~GDALPDFDictionaryPodofo()                   */
/************************************************************************/

GDALPDFDictionaryPodofo::~GDALPDFDictionaryPodofo()
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.begin();
    std::map<CPLString, GDALPDFObject*>::iterator oEnd = m_map.end();
    for(; oIter != oEnd; ++oIter)
        delete oIter->second;
}

/************************************************************************/
/*                                  Get()                               */
/************************************************************************/

GDALPDFObject* GDALPDFDictionaryPodofo::Get(const char* pszKey)
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.find(pszKey);
    if (oIter != m_map.end())
        return oIter->second;

    PoDoFo::PdfObject* poVal = m_poDict->GetKey(PoDoFo::PdfName(pszKey));
    if (poVal)
    {
         GDALPDFObjectPodofo* poObj = new GDALPDFObjectPodofo(poVal, m_poObjects);
         m_map[pszKey] = poObj;
         return poObj;
    }
    else
    {
        return nullptr;
    }
}

/************************************************************************/
/*                              GetValues()                             */
/************************************************************************/

std::map<CPLString, GDALPDFObject*>& GDALPDFDictionaryPodofo::GetValues()
{
    PoDoFo::TKeyMap::iterator oIter = m_poDict->GetKeys().begin();
    PoDoFo::TKeyMap::iterator oEnd = m_poDict->GetKeys().end();
    for( ; oIter != oEnd; ++oIter)
    {
        const char* pszKey = oIter->first.GetName().c_str();
        Get(pszKey);
    }

    return m_map;
}

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFArrayPodofo                         */
/* ==================================================================== */
/************************************************************************/

GDALPDFArrayPodofo::~GDALPDFArrayPodofo()
{
    for(size_t i=0;i<m_v.size();i++)
    {
        delete m_v[i];
    }
}

/************************************************************************/
/*                              GetLength()                             */
/************************************************************************/

int GDALPDFArrayPodofo::GetLength()
{
    return static_cast<int>(m_poArray->GetSize());
}

/************************************************************************/
/*                                Get()                                 */
/************************************************************************/

GDALPDFObject* GDALPDFArrayPodofo::Get(int nIndex)
{
    if (nIndex < 0 || nIndex >= GetLength())
        return nullptr;

    int nOldSize = static_cast<int>(m_v.size());
    if (nIndex >= nOldSize)
    {
        m_v.resize(nIndex+1);
        for(int i=nOldSize;i<=nIndex;i++)
        {
            m_v[i] = nullptr;
        }
    }

    if (m_v[nIndex] != nullptr)
        return m_v[nIndex];

    PoDoFo::PdfObject& oVal = (*m_poArray)[nIndex];
    GDALPDFObjectPodofo* poObj = new GDALPDFObjectPodofo(&oVal, m_poObjects);
    m_v[nIndex] = poObj;
    return poObj;
}

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFStreamPodofo                        */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                              GetLength()                             */
/************************************************************************/

int GDALPDFStreamPodofo::GetLength()
{
    char* pBuffer = nullptr;
    PoDoFo::pdf_long nLen = 0;
    try
    {
        m_pStream->GetFilteredCopy( &pBuffer, &nLen );
        PoDoFo::podofo_free(pBuffer);
        return (int)nLen;
    }
    catch( PoDoFo::PdfError & e )
    {
    }
    return 0;
}

/************************************************************************/
/*                               GetBytes()                             */
/************************************************************************/

char* GDALPDFStreamPodofo::GetBytes()
{
    char* pBuffer = nullptr;
    PoDoFo::pdf_long nLen = 0;
    try
    {
        m_pStream->GetFilteredCopy( &pBuffer, &nLen );
    }
    catch( PoDoFo::PdfError & e )
    {
        return nullptr;
    }
    char* pszContent = (char*) VSIMalloc(nLen + 1);
    if (!pszContent)
    {
        PoDoFo::podofo_free(pBuffer);
        return nullptr;
    }
    memcpy(pszContent, pBuffer, nLen);
    PoDoFo::podofo_free(pBuffer);
    pszContent[nLen] = '\\0';
    return pszContent;
}

/************************************************************************/
/*                             GetRawLength()                           */
/************************************************************************/

int GDALPDFStreamPodofo::GetRawLength()
{
    try
    {
        auto nLen = m_pStream->GetLength();
        return (int)nLen;
    }
    catch( PoDoFo::PdfError & e )
    {
    }
    return 0;
}

/************************************************************************/
/*                              GetRawBytes()                           */
/************************************************************************/

char* GDALPDFStreamPodofo::GetRawBytes()
{
    char* pBuffer = nullptr;
    PoDoFo::pdf_long nLen = 0;
    try
    {
        m_pStream->GetCopy( &pBuffer, &nLen );
    }
    catch( PoDoFo::PdfError & e )
    {
        return nullptr;
    }
    char* pszContent = (char*) VSIMalloc(nLen + 1);
    if (!pszContent)
    {
        PoDoFo::podofo_free(pBuffer);
        return nullptr;
    }
    memcpy(pszContent, pBuffer, nLen);
    PoDoFo::podofo_free(pBuffer);
    pszContent[nLen] = '\\0';
    return pszContent;
}

#endif // HAVE_PODOFO

#ifdef HAVE_PDFIUM

/************************************************************************/
/* ==================================================================== */
/*                         GDALPDFDictionaryPdfium                      */
/* ==================================================================== */
/************************************************************************/

class GDALPDFDictionaryPdfium: public GDALPDFDictionary
{
    private:
        CPDF_Dictionary* m_poDict;
        std::map<CPLString, GDALPDFObject*> m_map;

    public:
        GDALPDFDictionaryPdfium(CPDF_Dictionary* poDict) : m_poDict(poDict) {}
        virtual ~GDALPDFDictionaryPdfium();

        virtual GDALPDFObject* Get(const char* pszKey) override;
        virtual std::map<CPLString, GDALPDFObject*>& GetValues() override;
};

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFArrayPdfium                         */
/* ==================================================================== */
/************************************************************************/

class GDALPDFArrayPdfium : public GDALPDFArray
{
    private:
        CPDF_Array* m_poArray;
        std::vector<GDALPDFObject*> m_v;

    public:
        GDALPDFArrayPdfium(CPDF_Array* poArray) : m_poArray(poArray) {}
        virtual ~GDALPDFArrayPdfium();

        virtual int GetLength() override;
        virtual GDALPDFObject* Get(int nIndex) override;
};

/************************************************************************/
/* ==================================================================== */
/*                          GDALPDFStreamPdfium                         */
/* ==================================================================== */
/************************************************************************/

class GDALPDFStreamPdfium : public GDALPDFStream
{
    private:
        CPDF_Stream* m_pStream;
        int m_nSize = 0;
        std::unique_ptr<uint8_t, CPLFreeReleaser> m_pData = nullptr;
        int m_nRawSize = 0;
        std::unique_ptr<uint8_t, CPLFreeReleaser> m_pRawData = nullptr;

        void Decompress();
        void FillRaw();

    public:
        GDALPDFStreamPdfium( CPDF_Stream* pStream ) :
            m_pStream(pStream) {}
        virtual ~GDALPDFStreamPdfium() {}

        virtual int GetLength() override;
        virtual char* GetBytes() override;

        virtual int GetRawLength() override;
        virtual char* GetRawBytes() override;
};

/************************************************************************/
/* ==================================================================== */
/*                          GDALPDFObjectPdfium                         */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                          GDALPDFObjectPdfium()                       */
/************************************************************************/

GDALPDFObjectPdfium::GDALPDFObjectPdfium( CPDF_Object *po ) :
    m_po(po),
    m_poDict(nullptr),
    m_poArray(nullptr),
    m_poStream(nullptr)
{
    CPLAssert(m_po != nullptr);
}

/************************************************************************/
/*                         ~GDALPDFObjectPdfium()                       */
/************************************************************************/

GDALPDFObjectPdfium::~GDALPDFObjectPdfium()
{
    delete m_poDict;
    delete m_poArray;
    delete m_poStream;
}

/************************************************************************/
/*                               Build()                                */
/************************************************************************/

GDALPDFObjectPdfium* GDALPDFObjectPdfium::Build(CPDF_Object *poVal)
{
    if( poVal == nullptr )
        return nullptr;
    if( poVal->GetType() == CPDF_Object::Type::kReference )
    {
        poVal = poVal->GetDirect();
        if( poVal == nullptr )
        {
            CPLError(CE_Failure, CPLE_AppDefined, ""Cannot resolve indirect object"");
            return nullptr;
        }
    }
    return new GDALPDFObjectPdfium(poVal);
}

/************************************************************************/
/*                               GetType()                              */
/************************************************************************/

GDALPDFObjectType GDALPDFObjectPdfium::GetType()
{
    switch(m_po->GetType())
    {
        case CPDF_Object::Type::kNullobj:                  return PDFObjectType_Null;
        case CPDF_Object::Type::kBoolean:                  return PDFObjectType_Bool;
        case CPDF_Object::Type::kNumber:
          return (reinterpret_cast<CPDF_Number*>(m_po))->IsInteger()
              ? PDFObjectType_Int
              : PDFObjectType_Real;
        case CPDF_Object::Type::kString:                   return PDFObjectType_String;
        case CPDF_Object::Type::kName:                     return PDFObjectType_Name;
        case CPDF_Object::Type::kArray:                    return PDFObjectType_Array;
        case CPDF_Object::Type::kDictionary:               return PDFObjectType_Dictionary;
        case CPDF_Object::Type::kStream:                   return PDFObjectType_Dictionary;
        case CPDF_Object::Type::kReference:
            // unresolved reference
            return PDFObjectType_Unknown;
        default:
          CPLAssert(false);
          return PDFObjectType_Unknown;
    }
}

/************************************************************************/
/*                          GetTypeNameNative()                         */
/************************************************************************/

const char* GDALPDFObjectPdfium::GetTypeNameNative()
{
    if(m_po->GetType() == CPDF_Object::Type::kStream)
      return ""stream"";
    else
      return """";
}

/************************************************************************/
/*                              GetBool()                               */
/************************************************************************/

int GDALPDFObjectPdfium::GetBool()
{
    return m_po->GetInteger();
}

/************************************************************************/
/*                              GetInt()                                */
/************************************************************************/

int GDALPDFObjectPdfium::GetInt()
{
    return m_po->GetInteger();
}

/************************************************************************/
/*                       CPLRoundToMoreLikelyDouble()                   */
/************************************************************************/

// We try to compensate for rounding errors when converting the number
// in the PDF expressed as a string (e.g 297.84) to float32 by pdfium : 297.8399963378906
// Which is technically correct per the PDF spec, but in practice poppler or podofo use double
// and Geospatial PDF are often encoded with double precision.

static double CPLRoundToMoreLikelyDouble(float f)
{
    if( (float)(int)f == f )
        return f;

    char szBuffer[80];
    CPLsnprintf(szBuffer, 80, ""%f\\n"", f);
    double d = f;
    char* pszDot = strchr(szBuffer, '.');
    if( pszDot == nullptr )
        return d;
    pszDot ++;
    if( pszDot[0] == 0 || pszDot[1] == 0 )
        return d;
    if( STARTS_WITH(pszDot + 2, ""99"") )
    {
        pszDot[2] = 0;
        double d2 = CPLAtof(szBuffer) + 0.01;
        float f2 = (float)d2;
        if( f == f2 || nextafterf(f,f+1.0f) == f2 || nextafterf(f,f-1.0f) == f2 )
            d = d2;
    }
    else if( STARTS_WITH(pszDot + 2, ""00"") )
    {
        pszDot[2] = 0;
        double d2 = CPLAtof(szBuffer);
        float f2 = (float)d2;
        if( f == f2 || nextafterf(f,f+1.0f) == f2 || nextafterf(f,f-1.0f) == f2 )
            d = d2;
    }
    return d;
}

/************************************************************************/
/*                              GetReal()                               */
/************************************************************************/

double GDALPDFObjectPdfium::GetReal()
{
    return CPLRoundToMoreLikelyDouble(m_po->GetNumber());
}

/************************************************************************/
/*                              GetString()                             */
/************************************************************************/

const CPLString& GDALPDFObjectPdfium::GetString()
{
    if (GetType() == PDFObjectType_String) {
        const auto bs = m_po->GetString();
        // If empty string, code crashes
        if(bs.IsEmpty())
          return (osStr = """");
        return (osStr = GDALPDFGetUTF8StringFromBytes(static_cast<const GByte*>(bs.raw_str()),
                                                      static_cast<int>(bs.GetLength())));
    }
    else
        return (osStr = """");
}

/************************************************************************/
/*                              GetName()                               */
/************************************************************************/

const CPLString&  GDALPDFObjectPdfium::GetName()
{
    if (GetType() == PDFObjectType_Name)
        return (osStr = m_po->GetString().c_str());
    else
        return (osStr = """");
}

/************************************************************************/
/*                             GetDictionary()                          */
/************************************************************************/

GDALPDFDictionary* GDALPDFObjectPdfium::GetDictionary()
{
    if (GetType() != PDFObjectType_Dictionary)
        return nullptr;

    if (m_poDict)
        return m_poDict;

    m_poDict = new GDALPDFDictionaryPdfium(m_po->GetDict());
    return m_poDict;
}

/************************************************************************/
/*                                GetArray()                            */
/************************************************************************/

GDALPDFArray* GDALPDFObjectPdfium::GetArray()
{
    if (GetType() != PDFObjectType_Array)
        return nullptr;

    if (m_poArray)
        return m_poArray;

    m_poArray = new GDALPDFArrayPdfium(reinterpret_cast<CPDF_Array*>(m_po));
    return m_poArray;
}

/************************************************************************/
/*                               GetStream()                            */
/************************************************************************/

GDALPDFStream* GDALPDFObjectPdfium::GetStream()
{
    if (m_po->GetType() != CPDF_Object::Type::kStream)
        return nullptr;

    if (m_poStream)
        return m_poStream;
    CPDF_Stream* pStream = reinterpret_cast<CPDF_Stream*>(m_po);
    if (pStream)
    {
        m_poStream = new GDALPDFStreamPdfium(pStream);
        return m_poStream;
    }
    else
        return nullptr;
}

/************************************************************************/
/*                               GetRefNum()                            */
/************************************************************************/

GDALPDFObjectNum GDALPDFObjectPdfium::GetRefNum()
{
    return GDALPDFObjectNum(m_po->GetObjNum());
}

/************************************************************************/
/*                               GetRefGen()                            */
/************************************************************************/

int GDALPDFObjectPdfium::GetRefGen()
{
    return m_po->GetGenNum();
}

/************************************************************************/
/* ==================================================================== */
/*                         GDALPDFDictionaryPdfium                      */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                         ~GDALPDFDictionaryPdfium()                   */
/************************************************************************/

GDALPDFDictionaryPdfium::~GDALPDFDictionaryPdfium()
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.begin();
    std::map<CPLString, GDALPDFObject*>::iterator oEnd = m_map.end();
    for(; oIter != oEnd; ++oIter)
        delete oIter->second;
}

/************************************************************************/
/*                                  Get()                               */
/************************************************************************/

GDALPDFObject* GDALPDFDictionaryPdfium::Get(const char* pszKey)
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.find(pszKey);
    if (oIter != m_map.end())
        return oIter->second;

    ByteString pdfiumKey(pszKey);
    CPDF_Object* poVal = m_poDict->GetObjectFor(pdfiumKey);
    GDALPDFObjectPdfium* poObj = GDALPDFObjectPdfium::Build(poVal);
    if (poObj)
    {
        m_map[pszKey] = poObj;
        return poObj;
    }
    else
    {
        return nullptr;
    }
}

/************************************************************************/
/*                              GetValues()                             */
/************************************************************************/

std::map<CPLString, GDALPDFObject*>& GDALPDFDictionaryPdfium::GetValues()
{
    CPDF_DictionaryLocker dictIterator(m_poDict);
    for( const auto iter: dictIterator )
    {
        // No object for this key
        if( !iter.second )
            continue;

        const char* pszKey = iter.first.c_str();
        // Objects exists in the map
        if(m_map.find(pszKey) != m_map.end())
          continue;
        GDALPDFObjectPdfium* poObj = GDALPDFObjectPdfium::Build(iter.second.Get());
        if( poObj == nullptr )
            continue;
        m_map[pszKey] = poObj;
    }

    return m_map;
}

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFArrayPdfium                         */
/* ==================================================================== */
/************************************************************************/

GDALPDFArrayPdfium::~GDALPDFArrayPdfium()
{
    for(size_t i=0;i<m_v.size();i++)
    {
        delete m_v[i];
    }
}

/************************************************************************/
/*                              GetLength()                             */
/************************************************************************/

int GDALPDFArrayPdfium::GetLength()
{
    return static_cast<int>(m_poArray->size());
}

/************************************************************************/
/*                                Get()                                 */
/************************************************************************/

GDALPDFObject* GDALPDFArrayPdfium::Get(int nIndex)
{
    if (nIndex < 0 || nIndex >= GetLength())
        return nullptr;

    int nOldSize = static_cast<int>(m_v.size());
    if (nIndex >= nOldSize)
    {
        m_v.resize(nIndex+1);
        for(int i=nOldSize;i<=nIndex;i++)
        {
            m_v[i] = nullptr;
        }
    }

    if (m_v[nIndex] != nullptr)
        return m_v[nIndex];

    CPDF_Object* poVal = m_poArray->GetObjectAt(nIndex);
    GDALPDFObjectPdfium* poObj = GDALPDFObjectPdfium::Build(poVal);
    if( poObj == nullptr )
        return nullptr;
    m_v[nIndex] = poObj;
    return poObj;
}

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFStreamPdfium                        */
/* ==================================================================== */
/************************************************************************/

void GDALPDFStreamPdfium::Decompress()
{
    if( m_pData != nullptr )
        return;
    auto acc(pdfium::MakeRetain<CPDF_StreamAcc>(m_pStream));
    acc->LoadAllDataFiltered();
    m_nSize = static_cast<int>(acc->GetSize());
    m_pData.reset();
    // We don't use m_pData->Detach() as we don't want to deal with
    // std::unique_ptr<uint8_t, FxFreeDeleter>, and FxFreeDeleter behavior
    // depends on whether GDAL and pdfium are compiled with the same
    // NDEBUG and DCHECK_ALWAYS_ON settings
    if( m_nSize )
    {
        m_pData.reset(static_cast<uint8_t*>(CPLMalloc(m_nSize)));
        memcpy(&m_pData.get()[0], acc->GetData(), m_nSize);
    }
}

/************************************************************************/
/*                              GetLength()                             */
/************************************************************************/

int GDALPDFStreamPdfium::GetLength()
{
    Decompress();
    return m_nSize;
}

/************************************************************************/
/*                               GetBytes()                             */
/************************************************************************/

char* GDALPDFStreamPdfium::GetBytes()
{
    int nLength = GetLength();
    if(nLength == 0)
      return nullptr;
    char* pszContent = (char*) VSIMalloc(sizeof(char)*(nLength + 1));
    if (!pszContent)
        return nullptr;
    memcpy( pszContent, m_pData.get(), nLength);
    pszContent[nLength] = '\\0';
    return pszContent;
}

/************************************************************************/
/*                                FillRaw()                             */
/************************************************************************/

void GDALPDFStreamPdfium::FillRaw()
{
    if( m_pRawData != nullptr )
        return;
    auto acc(pdfium::MakeRetain<CPDF_StreamAcc>(m_pStream));
    acc->LoadAllDataRaw();
    m_nRawSize = static_cast<int>(acc->GetSize());
    m_pRawData.reset();
    // We don't use m_pData->Detach() as we don't want to deal with
    // std::unique_ptr<uint8_t, FxFreeDeleter>, and FxFreeDeleter behavior
    // depends on whether GDAL and pdfium are compiled with the same
    // NDEBUG and DCHECK_ALWAYS_ON settings
    if( m_nRawSize )
    {
        m_pRawData.reset(static_cast<uint8_t*>(CPLMalloc(m_nRawSize)));
        memcpy(&m_pRawData.get()[0], acc->GetData(), m_nRawSize);
    }
}

/************************************************************************/
/*                            GetRawLength()                            */
/************************************************************************/

int GDALPDFStreamPdfium::GetRawLength()
{
    FillRaw();
    return m_nRawSize;
}

/************************************************************************/
/*                             GetRawBytes()                            */
/************************************************************************/

char* GDALPDFStreamPdfium::GetRawBytes()
{
    int nLength = GetRawLength();
    if(nLength == 0)
      return nullptr;
    char* pszContent = (char*) VSIMalloc(sizeof(char)*(nLength + 1));
    if (!pszContent)
        return nullptr;
    memcpy( pszContent, m_pRawData.get(), nLength);
    pszContent[nLength] = '\\0';
    return pszContent;
}


#endif // HAVE_PDFIUM
",16277,True,3268.1699249703797,median
"/***************************************************************************
 *   Copyright (C) by GFZ Potsdam                                          *
 *                                                                         *
 *   You can redistribute and/or modify this program under the             *
 *   terms of the SeisComP Public License.                                 *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   SeisComP Public License for more details.                             *
 ***************************************************************************/

#include ""mvmainwindow.h""

#include <QGridLayout>

#define SEISCOMP_COMPONENT MapView
#include <seiscomp3/logging/log.h>

#include <seiscomp3/client/inventory.h>

#include <seiscomp3/core/datamessage.h>

#include <seiscomp3/gui/core/application.h>
#include <seiscomp3/gui/core/messages.h>
#include <seiscomp3/gui/datamodel/stationsymbol.h>
#include <seiscomp3/gui/datamodel/origindialog.h>
#include <seiscomp3/gui/datamodel/ttdecorator.h>
#include <seiscomp3/gui/map/projection.h>

#include <seiscomp3/datamodel/origin.h>
#include <seiscomp3/datamodel/focalmechanism.h>
#include <seiscomp3/datamodel/momenttensor.h>
#include <seiscomp3/datamodel/nodalplane.h>
#include <seiscomp3/datamodel/parameterset.h>
#include <seiscomp3/datamodel/parameter.h>
#include <seiscomp3/datamodel/inventory.h>
#include <seiscomp3/datamodel/utils.h>

#include <seiscomp3/utils/keyvalues.h>

#include <seiscomp3/math/math.h>
#include <seiscomp3/math/filter.h>
#include <seiscomp3/math/conversions.h>

#include ""types.h""
#include ""infowidget.h""

#include ""debug.h""

using namespace Seiscomp;

namespace {


DataModel::Amplitude* debugGetAmplitudeForPickFromDataBase(const std::string& publicID) {
	return SCApp->query()->getAmplitude(publicID, ""snr"");
}




inline std::string getStationId(const DataModel::WaveformStreamID* waveformID) {
	return waveformID->networkCode() + "".""
	       + waveformID->stationCode() + "".""
	       + waveformID->locationCode() + "".""
	       + waveformID->channelCode();
}




inline std::string getStationId(const DataModel::Pick* pick) {
	return getStationId(&pick->waveformID());
}




inline std::string getStationId(const DataModel::Amplitude* amplitude) {
	return getStationId(&amplitude->waveformID());
}




inline std::string getStationId(const Record* record) {
	return record->networkCode() + "".""
	       + record->stationCode() + "".""
	       + record->locationCode() + "".""
	       + record->channelCode();
}




inline std::string getStationId(DataModel::WaveformQuality* waveformQuality) {
	return getStationId(&waveformQuality->index().waveformID);
}




inline bool areOriginSymbolsVisible() {
	if ( ApplicationStatus::Instance()->mode() == ApplicationStatus::QC )
		return false;
	return true;
}




bool isFakeEvent(const DataModel::Event* event) {
    bool isFakeEvent = false;
    try {
        isFakeEvent = event->type() == DataModel::NOT_EXISTING ||
                      event->type() == DataModel::OTHER_EVENT;
        } catch ( Core::ValueException& ) {}

	return isFakeEvent;
}




bool hasEventCountChanged(const EventDataRepository& repository) {
	static int preceededEventCount = 0;
	if ( repository.eventCount() == preceededEventCount )
		return false;

	preceededEventCount = repository.eventCount();
	return true;
}




void addEventWidgetRowData(EventTableWidget::RowData& rowData,
                           const EventData& eventData,
                           const DataModel::Origin* origin) {
	QString eventId = QString(eventData.id().c_str());
	QString originTime(origin->time().value().toString(""%d.%m.%y %T"").c_str());

	QString eventRegion(DataModel::eventRegion(eventData.object()).c_str());

	double latitude = origin->latitude();
	QString latitudeValue = QString(""%1"").arg((latitude >= 0) ? latitude : latitude * (-1.0));
	QString latitudeOrientation = QString(""%1"").arg((latitude >= 0) ? ""N"" : """");

	double longitude = origin->longitude();
	QString longitudeValue = QString(""%1"").arg((longitude <= 0) ? longitude * (-1.0) : longitude);
	QString longitudeOrientation = QString(""%1"").arg((longitude <= 0) ? ""W"" : ""E"");

	QString depth = QString(""%1 km"").arg(static_cast<int> (Math::round(origin->depth())));

	rowData[EventTableWidget::EVENT_ID]     = eventId;
	rowData[EventTableWidget::ORIGIN_TIME]  = originTime;
	rowData[EventTableWidget::EVENT_REGION] = eventRegion;
	rowData[EventTableWidget::LATITUDE]     = latitudeValue + latitudeOrientation;
	rowData[EventTableWidget::LONGITUDE]    = longitudeValue + longitudeOrientation;
	rowData[EventTableWidget::DEPTH]        = depth;
}




void addEventWidgetRowData(EventTableWidget::RowData& rowData,
                           const DataModel::Magnitude* magnitude) {
	QString magnitudeValue = QString(""%1"").arg(magnitude->magnitude(), 0, 'f', 2);
	QString magnitudeType(magnitude->type().c_str());

	rowData[EventTableWidget::MAGNITUDE]      = magnitudeValue;
	rowData[EventTableWidget::MAGNITUDE_TYPE] = magnitudeType;
}




void showInfoWidget(InfoWidget* infoWidget) {
	infoWidget->init();
	infoWidget->move(QCursor::pos());
	infoWidget->show();
}




void configureInfoWidgetForRecordAcquisition(StationInfoWidget* infoWidget,
                                             const Core::TimeSpan& timeSpan,
                                             const std::string& filterStr) {
	infoWidget->setRecordSequeceTimeSpan(timeSpan);
	infoWidget->setRecordStreamUrl(SCApp->recordStreamURL());
	infoWidget->setRecordFilterString(filterStr);
}




void setInfoWidgetContent(StationInfoWidget* infoWidget, const DataModel::Amplitude* amplitude) {
	try	{
		QString time = amplitude->timeWindow().reference().toString(""%F-%T"").c_str();
		infoWidget->setAmplitudeTime(time);
	}
	catch ( Core::ValueException& ) {}

	QString amplitudeValue = QString(""%1"").arg(amplitude->amplitude().value());
	infoWidget->setAmplitudeMaxValue(amplitudeValue);

	try {
		Core::Time amplTime(amplitude->timeWindow().reference()
							+ Core::TimeSpan(amplitude->timeWindow().end()));
		QString amplitudeValueTime = amplTime.toString(""%F-%T"").c_str();
		infoWidget->setAmplitudeMaxValueTime(amplitudeValueTime);
	}
	catch ( Core::ValueException& )	{}
}




void setInfoWidgetContent(StationInfoWidget* infoWidget, DataModel::Station* station) {
	infoWidget->setLongitude(QString(""%1"").arg(station->longitude()));
	infoWidget->setLatitude(QString(""%1"").arg(station->latitude()));
	try { infoWidget->setElevation(QString(""%1"").arg(station->elevation())); }
	catch ( ... ) {}
	/* TODO: Find a replacement
	infoWidget->setDepth(QString(""%1"").arg(station->depth()));
	*/
	infoWidget->setPlace(station->place().c_str());
	infoWidget->setCountry(station->country().c_str());
	infoWidget->setDescription(station->description().c_str());
}




void setInfoWidgetContent(StationInfoWidget* infoWidget, StationData* stationData) {
	StationData::QcDataMap::iterator it = stationData->qcDataMap.begin();
	for ( ; it != stationData->qcDataMap.end(); it++ ) {
		StationData::QCData& data = it->second;

		QString name = it->first.toString();
		QString value = QString(""%1"").arg(data.value, 0, 'f', 2);
		QString lowerUncertainty = ""NaN"";
		QString upperUncertainty = ""NaN"";

		if ( std::numeric_limits<double>::quiet_NaN() != data.lowerUncertainty )
			lowerUncertainty = QString(""%1"").arg(data.lowerUncertainty, 0, 'f', 2);

		if ( std::numeric_limits<double>::quiet_NaN() != data.upperUncertainty )
			upperUncertainty = QString(""%1"").arg(data.upperUncertainty, 0, 'f', 2);

		QColor color = Qt::white;
		if ( data.status == QCStatus::OK )
			color = SCScheme.colors.qc.qcOk;
		else if ( data.status == QCStatus::WARNING )
			color = SCScheme.colors.qc.qcWarning;
		else if ( data.status == QCStatus::ERROR )
			color = SCScheme.colors.qc.qcError;

		infoWidget->setQCContent(name, value, lowerUncertainty, upperUncertainty, color);
	}
}




void setInfoWidgetContent(OriginInfoWidget* infoWidget, const DataModel::Origin* origin,
                          const std::string& preferredMagnitudeId) {
	infoWidget->setPreferredOriginId(origin->publicID().c_str());

	QString time = origin->time().value().toString(""%F - %T"").c_str();
	infoWidget->setTime(time);

	QString latitude = QString(""%1"").arg(origin->latitude());
	infoWidget->setLatitude(latitude);

	QString longitude = QString(""%1"").arg(origin->longitude());
	infoWidget->setLongitude(longitude);

	QString depth = QString(""%1"").arg(origin->depth());
	infoWidget->setDepth(depth);

	QString magnitude;
	for ( size_t i = 0; i < origin->magnitudeCount(); i++ ) {
		DataModel::Magnitude* magnitudeRef = origin->magnitude(i);
		if ( magnitudeRef->publicID() == preferredMagnitudeId ) {
			magnitude = QString(""%1"").arg(magnitudeRef->magnitude(), 0, 'f', 2);
			break;
		}
	}
	infoWidget->setMagnitude(magnitude);

	QString agency = QString(""%1"").fromStdString(objectAgencyID(origin).c_str());
	infoWidget->setAgency(agency);

	QString mode;
	try { mode = QString(""%1"").fromStdString(origin->evaluationMode().toString()); }
	catch ( Core::ValueException& ) {}
	infoWidget->setMode(mode);

	QString status;
	try { status = QString(""%1"").fromStdString(origin->evaluationStatus().toString()); }
	catch ( Core::ValueException& ) {}
	infoWidget->setStatus(status);

	QString stationCount = ""0"";
	try { stationCount = QString(""%1"").arg(origin->quality().usedStationCount()); }
	catch (Core::ValueException& e) {}
	infoWidget->setStationCount(stationCount);

	QString azimuthGap;
	try { azimuthGap = QString(""%1"").arg(origin->quality().azimuthalGap()); }
	catch (Core::ValueException& e) {}
	infoWidget->setAzimuthGap(azimuthGap);

	QString minimumDistance;
	try { minimumDistance = QString(""%1"").arg(origin->quality().minimumDistance()); }
	catch ( Core::ValueException& ) {}
	infoWidget->setMinimumDistance(minimumDistance);

	QString maximumDistance;
	try { maximumDistance = QString(""%1"").arg(origin->quality().maximumDistance()); }
	catch ( Core::ValueException ) {}
	infoWidget->setMaximumDistance(maximumDistance);
}




class StationRenderParameter {
	public:
		virtual ~StationRenderParameter() {}

	public:
		void setStationData(StationData* stationData) {
			_stationData = stationData;
		}

		virtual QColor color() const = 0;

		virtual QColor frameColor() const = 0;

		virtual int frameSize() const = 0;

		virtual Gui::Map::Symbol::Priority priority() const = 0;

		virtual char annotation() const {
			return StationGlyphs::DEFAULT;
		}

		virtual bool hasAnnotation() const {
			return false;
		}

	protected:
		StationData* stationData() const {
			return _stationData;
		}

	private:
		StationData* _stationData;
};




class DisabledStationRenderParameter : public StationRenderParameter {
	public:
		virtual QColor color() const {
			return SCScheme.colors.stations.disabled;
		}

		virtual QColor frameColor() const {
			return SCScheme.colors.stations.disabled;
		}

		virtual int frameSize() const {
			return TriggerHandler::STATION_DEFAULT_FRAME_SIZE;
		}

		virtual Gui::Map::Symbol::Priority priority() const {
			return Gui::Map::Symbol::NONE;
		}

		virtual char annotation() const {
			return StationGlyphs::DISABLED;
		}

		virtual bool hasAnnotation() const {
			return true;
		}
};




class GMStationRenderParameter : public StationRenderParameter {
	public:
		virtual QColor color() const {
			return stationData()->gmColor;
		}

		virtual QColor frameColor() const {
			if ( stationData()->isAssociated )
				return SCScheme.colors.stations.associated;

			if ( stationData()->isSelected )
				return SCScheme.colors.stations.selected;

			if ( stationData()->isTriggering )
				return SCScheme.colors.stations.triggering;

			return Qt::black;
		}

		virtual int frameSize() const {
			if ( !ApplicationStatus::Instance()->isTriggering() )
				return TriggerHandler::STATION_DEFAULT_FRAME_SIZE;

			if ( stationData()->isTriggering )
				return stationData()->frameSize;

			if ( stationData()->isAssociated )
				return TriggerHandler::STATION_DEFAULT_PICK_TRIGGER_FRAME_SIZE;

			if ( stationData()->isSelected )
				return TriggerHandler::STATION_DEFAULT_PICK_TRIGGER_FRAME_SIZE;

			return TriggerHandler::STATION_DEFAULT_FRAME_SIZE;
		}

		virtual Gui::Map::Symbol::Priority priority() const {
			bool emphasize = stationData()->isTriggering ||
			                 stationData()->isAssociated ||
			                 stationData()->isSelected;

			if ( emphasize )
				return Gui::Map::Symbol::MEDIUM;

			if ( stationData()->gmColor != SCScheme.colors.gm.gmNotSet )
				return Gui::Map::Symbol::LOW;

			return Gui::Map::Symbol::NONE;
		}
};




class QCStationRenderParameter : public StationRenderParameter {
	public:
		virtual QColor color() const {
			if ( QCParameter::Instance()->parameter() == QCParameter::DELAY )
				return stationData()->qcColor;

			QCParameter::Parameter parameter = QCParameter::Instance()->parameter();
			StationData::QCData data = stationData()->qcDataMap[parameter];
			QCStatus::Status status = data.status;

			if ( status == QCStatus::OK )
				return SCScheme.colors.qc.qcOk;

			if ( status == QCStatus::WARNING )
				return SCScheme.colors.qc.qcWarning;

			if ( status == QCStatus::ERROR )
				return SCScheme.colors.qc.qcError;

			return SCScheme.colors.qc.qcNotSet;
		}

		virtual QColor frameColor() const {
			return Qt::black;
		}

		virtual int frameSize() const {
			return TriggerHandler::STATION_DEFAULT_FRAME_SIZE;
		}

		virtual Gui::Map::Symbol::Priority priority() const {
			bool emphasize = stationData()->qcGlobalStatus == QCStatus::WARNING ||
			                 stationData()->qcGlobalStatus == QCStatus::ERROR ||
			                 stationData()->isSelected;
			if ( emphasize )
				return Gui::Map::Symbol::MEDIUM;

			if ( stationData()->qcGlobalStatus == QCStatus::OK )
				return Gui::Map::Symbol::LOW;

			return Gui::Map::Symbol::NONE;
		}

		virtual char annotation() const {
			if ( stationData()->qcGlobalStatus == QCStatus::WARNING )
				return StationGlyphs::WARNING;

			if ( stationData()->qcGlobalStatus == QCStatus::ERROR )
				return StationGlyphs::ERROR;

			return StationGlyphs::DEFAULT;
		}

		virtual bool hasAnnotation() const {
			if ( stationData()->qcGlobalStatus > QCStatus::OK )
				return true;
			return false;
		}

};



StationRenderParameter* selectRenderParameterInstance(bool isStationEnabled) {
	if ( !isStationEnabled ) {
		static DisabledStationRenderParameter disabledRenderParameter;
		return &disabledRenderParameter;
	}

	StationRenderParameter* parameter = NULL;
	if ( ApplicationStatus::Instance()->mode() == ApplicationStatus::GROUND_MOTION ) {
		static GMStationRenderParameter gmParameter;
		parameter = &gmParameter;
	}
	else if ( ApplicationStatus::Instance()->mode() == ApplicationStatus::EVENT ) {
		static GMStationRenderParameter eventParameter;
		return &eventParameter;
	}
	else if ( ApplicationStatus::Instance()->mode() == ApplicationStatus::QC ) {
		static QCStationRenderParameter qcParameter;
		parameter = &qcParameter;
	}

	return parameter;
}




DisplayMode selectDisplayModeFromString(const std::string& mode) {
	if ( mode == ""groundmotion"")
		return GROUND_MOTION;

	if ( mode == ""qualitycontrol"" )
		return QUALITY_CONTROL;

	return NONE;
}




QWidget* selectTabFromDisplayMode(DisplayMode mode, const Ui::MvMainWindow& ui) {
	if ( mode == GROUND_MOTION )
		return ui.gmTab;

	if ( mode == QUALITY_CONTROL )
		return ui.qcTab;

	return NULL;
}


} // namespace




MvMainWindow::MvMainWindow(QWidget* parent, Qt::WFlags flags)
 : Gui::MainWindow(parent, flags),
   _mapWidget(NULL),
   _displayMode(NONE),
   _mapUpdateInterval(1E3),
   _configStationPickCacheLifeSpan(15 * 60),
   _configEventActivityLifeSpan(15 * 60),
   _configRemoveEventDataOlderThanTimeSpan(static_cast<double>(12 * 3600)),
   _configReadEventsNotOlderThanTimeSpan(0.0),
   _configStationRecordFilterStr(""RMHP(50)->ITAPER(20)->BW(2,0.04,2)"") {

	setupStandardUi();
}




bool MvMainWindow::init() {
	if ( !SCApp->query() ) {
		SEISCOMP_ERROR(""No database is configured, abort"");
		return false;
	}

	_qcHandler.init(SCApp->configuration());

	// Overwrite default menu settings
	try {
		_ui.showMapLegendAction->setChecked(SCApp->configGetBool(""legend""));
	}
	catch ( ... ) {}

	try {
		_ui.showStationIdAction->setChecked(SCApp->configGetBool(""annotations""));
	}
	catch ( ... ) {}

	try {
		_ui.actionShowStationChannelCodes->setChecked(SCApp->configGetBool(""annotationsWithChannels""));
	}
	catch ( ... ) {}

	std::string displayMode;
	try {
		displayMode = SCApp->configGetString(""displaymode"");
	} catch ( Config::Exception& ) {}

	if ( SCApp->commandline().hasOption(""displaymode"") ) {
		displayMode = SCApp->commandline().option<std::string>(""displaymode"");
	}

	_displayMode = selectDisplayModeFromString(displayMode);
	bool isDisplayModeStringInvalid = _displayMode == NONE && !displayMode.empty();
	if ( isDisplayModeStringInvalid ) {
		SEISCOMP_ERROR(""Invalid displaymode found: %s"", displayMode.c_str());
		return false;
	}

	if ( isInDisplayMode() )
		modifyUiSetupForDisplayMode();

	try {
		int recordLifeSpan = SCApp->configGetInt(""groundMotionRecordLifeSpan"");
		_recordHandler.setRecordLifeSpan(recordLifeSpan);
	} catch ( Config::Exception& ) {}

	_triggerHandler.setPickLifeSpan(_configStationPickCacheLifeSpan);

	if ( !readStationsFromDataBase() ) {
		SEISCOMP_ERROR(""Could not read stations from database"");
		return false;
	}

	try {
		_configStationRecordFilterStr = SCApp->configGetString(""stations.groundMotionFilter"");
	} catch ( Config::Exception& ) {}

	StationDataCollection::iterator stationIt = _stationDataCollection.begin();
	for ( ; stationIt != _stationDataCollection.end(); ++stationIt )
		stationIt->gmFilter = StationData::GmFilterPtr(Math::Filtering::InPlaceFilter<double>::Create(_configStationRecordFilterStr));

	if ( !initRecordStream() ) {
		SEISCOMP_ERROR(""Could not initialize record stream"");
	}

	try {
		_configRemoveEventDataOlderThanTimeSpan = SCApp->configGetDouble(""removeEventDataOlderThan"");
	} catch ( Config::Exception& ) {}
	_eventDataRepository.setEventDataLifeSpan(_configRemoveEventDataOlderThanTimeSpan);
	_eventDataRepository.setDatabaseArchive(SCApp->query());

	try {
		bool centerOrigins = SCApp->configGetBool(""centerOrigins"");
		if ( centerOrigins )
			_ui.centerOriginForLatestEventAction->setChecked(true);
	} catch ( Config::Exception& ) {}

	try {
		_configReadEventsNotOlderThanTimeSpan = SCApp->configGetDouble(""readEventsNotOlderThan"");
	} catch ( Config::Exception& ) {}
	readEventsFromDataBaseNotOlderThan(_configReadEventsNotOlderThanTimeSpan);
	updateEventWidget();
	if ( areOriginSymbolsVisible() )
		updateOriginSymbolDisplay();
	if ( _configReadEventsNotOlderThanTimeSpan.seconds() > 0 )
		readPicksFromDataBaseNotOlderThan(_configStationPickCacheLifeSpan);
	if ( _ui.centerOriginForLatestEventAction->isChecked() )
		centerOriginForLatestEvent();

#ifdef DEBUG_EVENTS
	std::cerr << ""= Total read events from database = "" << std::endl;
	std::cerr << "" * Number of events: "" << _eventDataRepository.eventCount() << std::endl;

	EventDataRepository::const_event_iterator eventIt = _eventDataRepository.eventsBegin();
	for ( ; eventIt != _eventDataRepository.eventsEnd(); eventIt++ )
		std::cerr << eventIt->id() << std::endl;
#endif

	try {
		_configEventActivityLifeSpan = SCApp->configGetDouble(""eventActivityLifeSpan"");
	} catch ( Config::Exception& ) {}

	return true;
}




bool MvMainWindow::eventFilter(QObject* object, QEvent* event) {
	if ( object == _mapWidget ) {
		if ( event->type() == QEvent::MouseButtonPress ) {
			QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);

			if ( mouseEvent->button() == Qt::LeftButton	&& mouseEvent->modifiers() == Qt::ShiftModifier ) {
				QPoint pos = QPoint(mouseEvent->x(), mouseEvent->y());
				showMapCoordinates(pos);
				return true;
			}
			else if ( mouseEvent->button() == Qt::MidButton ) {
				QPoint pos = QPoint(mouseEvent->x(), mouseEvent->y());
				sendArtificialOrigin(pos);
				return true;
			}
		}
		else if ( event->type() == QEvent::ContextMenu ) {
			QContextMenuEvent* contextMenuEvent = static_cast<QContextMenuEvent*>(event);
			return handleMapContextMenu(contextMenuEvent);
		}
	}

	return Seiscomp::Gui::MainWindow::eventFilter(object, event);
}



void MvMainWindow::closeEvent(QCloseEvent *e) {
	if ( _recordStreamThread.get() )
		_recordStreamThread->stop(true);
}


void MvMainWindow::setupStandardUi() {
	_ui.setupUi(this);

	addAction(_ui.showMapLegendAction);
	addAction(_ui.showWaveformPropagationAction);
	addAction(_ui.showHistoricOriginsAction);

	_ui.splitter->setStretchFactor(0, 1);

	// Setup menu
	_ui.showEventTableWidgetAction->setChecked(false);
	_ui.showWaveformPropagationAction->setChecked(true);
	_ui.showMapLegendAction->setChecked(true);
	_ui.showHistoricOriginsAction->setChecked(true);

	_eventTableWidgetRef = new EventTableWidget;
	_eventTableWidgetRef->setVisible(_ui.showEventTableWidgetAction->isChecked());
	_ui.splitter->addWidget(_eventTableWidgetRef);

	// Setup map
	_ui.gmTab->setLayout(new QGridLayout);
	_ui.gmTab->layout()->setMargin(0);
	_ui.gmTab->layout()->setSpacing(0);

	_ui.eventTab->setLayout(new QGridLayout);
	_ui.eventTab->layout()->setMargin(0);
	_ui.eventTab->layout()->setSpacing(0);

	int index = _ui.tabWidget->indexOf(_ui.eventTab);
	_ui.tabWidget->removeTab(index);

	_ui.qcTab->setLayout(new QGridLayout);
	_ui.qcTab->layout()->setMargin(0);
	_ui.qcTab->layout()->setSpacing(0);

	QWidget* currentTab = _ui.gmTab;
	_ui.tabWidget->setCurrentWidget(currentTab);

	_mapWidget = new MvMapWidget(SCApp->mapsDesc());
	_mapWidget->installEventFilter(this);

	double lonmin = -180, lonmax = 180, latmin = -90, latmax = 90;
	try { lonmin = SCApp->configGetDouble(""display.lonmin""); } catch (Config::Exception) {}
	try { lonmax = SCApp->configGetDouble(""display.lonmax""); } catch (Config::Exception) {}
	try { latmin = SCApp->configGetDouble(""display.latmin""); } catch (Config::Exception) {}
	try { latmax = SCApp->configGetDouble(""display.latmax""); } catch (Config::Exception) {}

	QRectF displayRect;
	displayRect.setRect(lonmin, latmin, lonmax-lonmin, latmax-latmin);
	_mapWidget->canvas().displayRect(displayRect);

	_ui.gmTab->layout()->addWidget(_mapWidget);

	connect(_ui.tabWidget, SIGNAL(currentChanged(int)), this, SLOT(changeView(int)));

	connect(_ui.showWaveformPropagationAction, SIGNAL(toggled(bool)), this, SLOT(setWaveformPropagationVisible(bool)));
	connect(_ui.showEventTableWidgetAction, SIGNAL(toggled(bool)), _eventTableWidgetRef, SLOT(setVisible(bool)));
	connect(_ui.showStationIdAction, SIGNAL(toggled(bool)), this, SLOT(setStationIdVisible(bool)));
	connect(_ui.actionShowStationChannelCodes, SIGNAL(toggled(bool)), this, SLOT(setStationChannelCodesVisible(bool)));
	connect(_ui.showMapLegendAction, SIGNAL(toggled(bool)), _mapWidget, SLOT(showMapLegend(bool)));
	connect(_ui.showHistoricOriginsAction, SIGNAL(toggled(bool)), this, SLOT(updateOriginSymbolDisplay()));
	connect(_ui.searchStationAction, SIGNAL(triggered(bool)), this, SLOT(showSearchWidget()));
	connect(_ui.centerOriginForLatestEventAction, SIGNAL(triggered(bool)), this, SLOT(centerOriginForLatestEvent()));
	connect(_ui.resetAction, SIGNAL(triggered()), this, SLOT(resetStationData()));
	connect(_ui.quitAction, SIGNAL(triggered()), SCApp, SLOT(quit()));

	connect(_ui.qcLatencyAction, SIGNAL(triggered()), &_qualityControlStatusSelector, SLOT(selectLatency()));
	connect(_ui.qcDelayAction, SIGNAL(triggered()), &_qualityControlStatusSelector, SLOT(selectDelay()));
	connect(_ui.qcTimingQualityAction, SIGNAL(triggered()), &_qualityControlStatusSelector, SLOT(selectTimingQuality()));
	connect(_ui.qcGapsIntervalAction, SIGNAL(triggered()), &_qualityControlStatusSelector, SLOT(selectGapsInterval()));
	connect(_ui.qcGapsLengthAction, SIGNAL(triggered()), &_qualityControlStatusSelector, SLOT(selectGapsLength()));
	connect(_ui.qcOverlapsIntervalAction, SIGNAL(triggered()), &_qualityControlStatusSelector, SLOT(selectOverlapsInterval()));
	connect(_ui.qcAvailabilityAction, SIGNAL(triggered()), &_qualityControlStatusSelector, SLOT(selectAvailability()));
	connect(_ui.qcOffsetAction, SIGNAL(triggered()), &_qualityControlStatusSelector, SLOT(selectOffset()));
	connect(_ui.qcRmsAction, SIGNAL(triggered()), &_qualityControlStatusSelector, SLOT(selectRms()));

	connect(_eventTableWidgetRef, SIGNAL(eventSelected(const QString&)), this, SLOT(selectStationsForEvent(const QString&)));
	connect(_eventTableWidgetRef, SIGNAL(eventSelected(const QString&)), this, SLOT(selectEvent(const QString&)));

	connect(_eventTableWidgetRef, SIGNAL(eventDoubleClicked(const QString&)), this, SLOT(centerOriginForEvent(const QString&)));
	connect(_eventTableWidgetRef, SIGNAL(eventDoubleClicked(const QString&)), this, SLOT(selectStationsForEvent(const QString&)));
	connect(_eventTableWidgetRef, SIGNAL(eventDoubleClicked(const QString&)), this, SLOT(selectEvent(const QString&)));

	connect(_eventTableWidgetRef, SIGNAL(eventDeselected(const QString&)), this, SLOT(deselectEvents()));
	connect(_eventTableWidgetRef, SIGNAL(eventDeselected(const QString&)), this, SLOT(deselectStations()));

	connect(SCApp, SIGNAL(messageAvailable(Seiscomp::Core::Message*, Seiscomp::Communication::NetworkMessage*)),
	        this, SLOT(handleNewMessage(Seiscomp::Core::Message*)));

	connect(&_mapUpdateTimer, SIGNAL(timeout()), this, SLOT(updateMap()));

	_mapUpdateTimer.start(_mapUpdateInterval);
}




void MvMainWindow::modifyUiSetupForDisplayMode() {
	// Overwrite default menu settings
	bool showLegend = false;

	try { showLegend = SCApp->configGetBool(""legend""); } catch ( ... ) {}
	if ( SCApp->commandline().hasOption(""with-legend"") ) showLegend = true;

	_ui.showMapLegendAction->setChecked(showLegend);
	_ui.showHistoricOriginsAction->setChecked(false);

	QWidget* currentTab = _ui.tabWidget->currentWidget();
	currentTab->layout()->removeWidget(_mapWidget);

	this->setCentralWidget(_mapWidget);
	_eventTableWidgetRef = NULL;

	menuBar()->setVisible(false);
	statusBar()->setVisible(false);

	if ( _displayMode == GROUND_MOTION )
		ApplicationStatus::Instance()->setMode(ApplicationStatus::GROUND_MOTION);
	else if ( _displayMode == QUALITY_CONTROL )
		ApplicationStatus::Instance()->setMode(ApplicationStatus::QC);
}




bool MvMainWindow::initRecordStream() {
	if ( !SCApp->isRecordStreamEnabled() ) {
		SEISCOMP_DEBUG(""No record stream source specified"");
		return false;
	}

	_recordStreamThread = RecordStreamThreadPtr(new Gui::RecordStreamThread(SCApp->recordStreamURL()));

	if ( !_recordStreamThread->connect() ) {
		SEISCOMP_ERROR(""Could not open recordstream %s"", SCApp->recordStreamURL().c_str());
		return false;
	}

	connect(_recordStreamThread.get(), SIGNAL(receivedRecord(Seiscomp::Record*)),
			this, SLOT(handleNewRecord(Seiscomp::Record*)));

	StationDataCollection::iterator it = _stationDataCollection.begin();
	for ( ; it != _stationDataCollection.end(); ++it ) {
		std::vector<std::string> tokens;
		Core::split(tokens, it->id.c_str(), ""."", false);

		_recordStreamThread->addStream(tokens[0],tokens[1],tokens[2], tokens[3]);

		try {
			it->gmGain = Client::Inventory::Instance()->getGain(tokens[0], tokens[1], tokens[2], tokens[3], Core::Time::GMT());
		}
		catch ( ... ) {}
	}

	_recordStreamThread->start();

	return true;
}




void MvMainWindow::showMapCoordinates(const QPoint& pos) {
	QPointF mapPos;
	if ( !_mapWidget->canvas().projection()->unproject(mapPos, pos) ) return;

	statusBar()->showMessage(QString(""Latitude: %1 Longitude: %2"") .arg(mapPos.y()).arg(mapPos.x()), int(2E3));
}




bool MvMainWindow::handleMapContextMenu(QContextMenuEvent* contextMenuEvent) {
	typedef std::vector<QAction*> ActionCollection;
	ActionCollection stationActionCollection;
	ActionCollection originActionCollection;

	Gui::Map::SymbolCollection::const_iterator it = _mapWidget->canvas().symbolCollection()->begin();
	for ( ; it != _mapWidget->canvas().symbolCollection()->end(); it++ ) {
		Gui::Map::Symbol* mapSymbol = *it;

		if ( !mapSymbol->isInside(contextMenuEvent->x(), contextMenuEvent->y()) )
			continue;

		if ( mapSymbol->typeInfo() == Gui::OriginSymbol::TypeInfo() ) {
			QString title = QString(""Event %1"").arg(mapSymbol->id().c_str());
			QAction* action = createAndConfigureContextMenuAction(title, mapSymbol);

			originActionCollection.push_back(action);
		}
		else if ( mapSymbol->typeInfo() == MvStationSymbol::TypeInfo() ) {
			QString title = QString(""Station: %1"").arg(mapSymbol->id().c_str());
			QAction* action = createAndConfigureContextMenuAction(title, mapSymbol);

			StationData* stationData = _stationDataCollection.find(mapSymbol->id());
			if ( stationData->tAmplitudeTime != Core::Time::Null ) {
				QFont font;
				font.setBold(true);
				action->setFont(font);
			}

			stationActionCollection.push_back(action);
		}
	}

	QMenu menu(""Select Mapsymbol"", this);
	addOriginsToContextMenu(menu, originActionCollection);
	addStationsToContextMenu(menu, stationActionCollection);

	if ( !menu.isEmpty()) {
		menu.exec(contextMenuEvent->globalPos());
		return true;
	}
	return false;
}




QAction* MvMainWindow::createAndConfigureContextMenuAction(const QString& title, Gui::Map::Symbol* mapSymbol) {
	QAction* action = new QAction(title, NULL);

	QVariant variant = qVariantFromValue(static_cast<void*>(mapSymbol));
	action->setData(variant);

	connect(action, SIGNAL(triggered()), this, SLOT(showInfoWidget()));

	return action;
}




void MvMainWindow::addStationsToContextMenu(QMenu& menu, std::vector<QAction*>& collection) {
	bool hasActiveArrival = false;
	std::vector<QAction*>::iterator it = collection.begin();
	for ( ; it != collection.end(); it++ ) {
		bool hasBoldFont = (*it)->font().bold();
		if ( hasBoldFont ) {
			menu.addAction(*it);
			hasActiveArrival = true;
		}
	}

	if ( hasActiveArrival )
		menu.addSeparator();

	it = collection.begin();
	for ( ; it != collection.end(); it++ ) {
		bool hasBoldFont = (*it)->font().bold();
		if ( !hasBoldFont )
			menu.addAction(*it);
	}
}




void MvMainWindow::addOriginsToContextMenu(QMenu& menu, std::vector<QAction*>& collection) {
	std::vector<QAction*>::iterator it = collection.begin();
	for ( ; it != collection.end(); it++ ) {
		menu.addAction(*it);
	}

	if ( !collection.empty() )
		menu.addSeparator();
}




void MvMainWindow::sendArtificialOrigin(const QPoint& pos) {
	QPointF mapPos;
	if ( !_mapWidget->canvas().projection()->unproject(mapPos, pos) ) return;

	Gui::OriginDialog dialog(mapPos.x(), mapPos.y(), this);
	dialog.move(pos);
	if ( dialog.exec() != QDialog::Accepted ) return;

	DataModel::Origin* origin = DataModel::Origin::Create();
	DataModel::CreationInfo ci;

	ci.setAgencyID(SCApp->agencyID());
	ci.setAuthor(SCApp->author());
	ci.setCreationTime(Core::Time::GMT());

	origin->setCreationInfo(ci);
	origin->setLongitude(dialog.longitude());
	origin->setLatitude(dialog.latitude());
	origin->setDepth(DataModel::RealQuantity(dialog.depth()));
	origin->setTime(Core::Time(dialog.getTime_t()));

	SCApp->sendCommand(Gui::CM_OBSERVE_LOCATION, """", origin);
}




void MvMainWindow::updateMap() {
	ApplicationStatus::Instance()->setTriggering(!ApplicationStatus::Instance()->isTriggering());

	updateEventData();

	StationDataCollection::iterator it = _stationDataCollection.begin();
	for ( ; it != _stationDataCollection.end(); ++it ) {
		_recordHandler.update(&(*it));
		_triggerHandler.update(&(*it));
		_qcHandler.update(&(*it));

		StationRenderParameter* renderTraits = selectRenderParameterInstance(it->isEnabled);
		renderTraits->setStationData(&(*it));

		it->stationSymbolRef->setColor(renderTraits->color());
		it->stationSymbolRef->setFrameColor(renderTraits->frameColor());
		it->stationSymbolRef->setFrameSize(renderTraits->frameSize());
		it->stationSymbolRef->setPriority(renderTraits->priority());

		it->stationSymbolRef->setCharacterDrawingEnabled(false);
		if ( renderTraits->hasAnnotation() ) {
			it->stationSymbolRef->setCharacterDrawingEnabled(true);
			it->stationSymbolRef->setCharacterDrawingColor(SCScheme.colors.stations.text);
			it->stationSymbolRef->setCharacter(renderTraits->annotation());
		}
	}

	// FIX: Is this the only way to update the mapWidget? A simple
	// update didn't suffice
	_mapWidget->update();
}




void MvMainWindow::changeView(int index) {
	QWidget* precedingTab = _ui.tabWidget->currentWidget();
	precedingTab->layout()->removeWidget(_mapWidget);

	QWidget* w = _ui.tabWidget->widget(index);
	w->layout()->addWidget(_mapWidget);

	bool isQcTabSelected = precedingTab != _ui.qcTab &&
	                       _ui.tabWidget->currentWidget() == _ui.qcTab;

	bool isQcTabDeselected = precedingTab == _ui.qcTab &&
	                         _ui.tabWidget->currentWidget() != _ui.qcTab;

	if ( isQcTabSelected ) {
		showOriginSymbols(false);
		disconnect(_ui.showHistoricOriginsAction, 0, 0, 0);
	}
	else if ( isQcTabDeselected ) {
		updateOriginSymbolDisplay();
		connect(_ui.showHistoricOriginsAction, SIGNAL(toggled(bool)),
		        this, SLOT(updateOriginSymbolDisplay()));
	}

	if ( _ui.tabWidget->currentWidget() == _ui.gmTab )
		ApplicationStatus::Instance()->setMode(ApplicationStatus::GROUND_MOTION);
	else if ( _ui.tabWidget->currentWidget() == _ui.eventTab )
		ApplicationStatus::Instance()->setMode(ApplicationStatus::EVENT);
	else if ( _ui.tabWidget->currentWidget() == _ui.qcTab )
		ApplicationStatus::Instance()->setMode(ApplicationStatus::QC);

	_mapWidget->setMode(ApplicationStatus::Instance()->mode());
}




bool MvMainWindow::readStationsFromDataBase() {
	// Read configured streams
	DataModel::ConfigModule *module = SCApp->configModule();
	if ( !module ) return false;

	std::map<std::string, StationData> stations;

	for ( size_t i = 0; i < module->configStationCount(); ++i ) {
		DataModel::ConfigStation *cs = module->configStation(i);
		DataModel::Setup *setup = findSetup(cs, SCApp->name());
		if ( setup ) {
			DataModel::ParameterSet* ps = DataModel::ParameterSet::Find(setup->parameterSetID());
			if ( !ps ) {
				SEISCOMP_ERROR(""Cannot find parameter set %s"", setup->parameterSetID().c_str());
				continue;
			}

			std::string net = cs->networkCode();
			std::string sta = cs->stationCode();

			Util::KeyValues params;
			params.init(ps);

			std::string location;
			std::string channel;

			params.getString(location, ""detecLocid"");
			params.getString(channel, ""detecStream"");

			if ( channel.empty() ) continue;

			if ( channel.size() < 3 ) {
				char compCode = 'Z';
				DataModel::SensorLocation *sloc = Client::Inventory::Instance()->getSensorLocation(net, sta, location, Core::Time::GMT());
				if ( sloc ) {
					DataModel::Stream *stream = DataModel::getVerticalComponent(sloc, channel.c_str(), Core::Time::GMT());
					if ( stream )
						channel = stream->code();
					else
						channel += compCode;
				}
				else
					channel += compCode;
			}

			StationData stationData;
			stationData.id = net + ""."" + sta + ""."" + location + ""."" + channel;
			stationData.isEnabled = cs->enabled();
			stations.insert(make_pair(net + ""."" + sta, stationData));
			SEISCOMP_DEBUG(""Adding station id: %s"", stationData.id.data());
		}
	}

	// Read configured stations
	DataModel::Inventory* inventory = Client::Inventory::Instance()->inventory();
	if ( !inventory ) return false;

	Core::Time now = Core::Time::GMT();

	for ( size_t i = 0; i < inventory->networkCount(); ++i ) {
		DataModel::NetworkPtr network = inventory->network(i);
		for ( size_t j = 0; j < network->stationCount(); ++j ) {
			DataModel::StationPtr station = network->station(j);
			if ( station->start() > now ) continue;

			try {
				if ( station->end() < now ) continue;
			}
			catch ( Core::ValueException& ) {}

			if ( _mapWidget->canvas().isInside(station->longitude(), station->latitude()) ) {
				std::string key = station->network()->code() + ""."" + station->code();
				std::map<std::string, StationData>::iterator it = stations.find(key);
				if ( it == stations.end() ) continue;

				it->second.stationRef = station;
				it->second.stationSymbolRef = new MvStationSymbol(station->latitude(),
				                                                  station->longitude());
				it->second.stationSymbolRef->setID(it->second.id);
				it->second.stationSymbolRef->setNetworkCode(station->network()->code());
				it->second.stationSymbolRef->setStationCode(station->code());
				it->second.stationSymbolRef->setIdDrawingColor(SCScheme.colors.map.stationAnnotations);
				it->second.stationSymbolRef->setIdDrawingEnabled(_ui.showStationIdAction->isChecked());
				it->second.stationSymbolRef->setDrawFullID(_ui.actionShowStationChannelCodes->isChecked());

				_stationDataCollection.add(it->second);
				_mapWidget->canvas().symbolCollection()->add(it->second.stationSymbolRef);
				SEISCOMP_DEBUG(""Adding station symbol: %s"", key.data());
			}
		}
	}

	return true;
}




void MvMainWindow::readPicksFromDataBaseNotOlderThan(const Core::TimeSpan& timeSpan) {
	Core::Time begin = Core::Time::GMT() - timeSpan;
	Core::Time end = Core::Time::GMT();

#ifdef DEBUG_AMPLITUDES
	std::vector<std::string> pickIds;
#endif

	DataModel::DatabaseIterator it = SCApp->query()->getPicks(begin, end);
	for ( ; *it != NULL; ++it ) {
		DataModel::Pick* pick = DataModel::Pick::Cast(*it);
		if ( !pick ) continue;

		handleNewPick(pick);

#ifdef DEBUG_AMPLITUDES
		pickIds.push_back(pick->publicID());
#endif

	}

#ifdef DEBUG_AMPLITUDES
	size_t count = 0;
	for ( std::vector<std::string>::const_iterator it = pickIds.begin();
			it != pickIds.end(); it++ ) {
		DataModel::Amplitude* amplitude = debugGetAmplitudeForPickFromDataBase(*it);
		if ( amplitude ) {
			handleNewAmplitude(amplitude);
		}
		else {
			std::cerr << ""Could not get amplitude for pick "" << *it << "" from database"" << std::endl;
			count++;
		}
	}
	std::cerr << ""A total of "" << count << "" could not be retrieved from database"" << std::endl;
#endif

}




void MvMainWindow::readEventsFromDataBaseNotOlderThan(const Seiscomp::Core::TimeSpan& timeSpan) {
	Core::Time begin = Core::Time::GMT() - timeSpan;
	Core::Time end = Core::Time::GMT();

	typedef std::vector<DataModel::EventPtr> EventCollection;
	EventCollection events;

	DataModel::DatabaseIterator it = SCApp->query()->getEvents(begin, end);
	for ( ; *it; ++it ) {
		DataModel::Event* event = DataModel::Event::Cast(*it);
		if ( !event ) continue;
		if ( isFakeEvent(event) ) {
			SEISCOMP_DEBUG(""Skipping fake event %s"", event->publicID().c_str());
			continue;
		}

		events.push_back(event);
	}

	EventCollection::iterator eventIt = events.begin();
	for ( ; eventIt != events.end(); eventIt++ ) {
		std::string eventId = (*eventIt)->publicID();
		std::string preferredOriginId = (*eventIt)->preferredOriginID();

		DataModel::Origin* origin = DataModel::Origin::Cast(SCApp->query()->getObject(DataModel::Origin::TypeInfo(),
		                                                                              preferredOriginId));
		if ( !origin ) {
			SEISCOMP_DEBUG(""Preferred origin not found, skipping event %s"", eventId.c_str());
			continue;
		}

		SCApp->query()->load(origin);
		handleNewOrigin(origin);

		std::string preferredMagnitudeId = (*eventIt)->preferredMagnitudeID();
		DataModel::Magnitude* magnitude =
				DataModel::Magnitude::Cast(SCApp->query()->getObject(DataModel::Magnitude::TypeInfo(),
				                                                     preferredMagnitudeId));
		if ( !magnitude ) {
			SEISCOMP_DEBUG(""Preferred magnitude not found, skipping event %s"", eventId.c_str());
			continue;
		}

		handleNewMagnitude(magnitude);

		SCApp->query()->load((*eventIt).get());
		handleNewEvent((*eventIt).get());
	}
}




void MvMainWindow::handleNewConfigStation(const DataModel::ConfigStation* configStation) {
	StationDataCollection::iterator it = _stationDataCollection.begin();
	for ( ; it != _stationDataCollection.end(); it++ ) {
		std::vector<std::string> tokens;
		Core::split(tokens, it->id.c_str(), ""."", false);

		bool match = tokens[0] == configStation->networkCode() &&
					 tokens[1] == configStation->stationCode();
		if ( match )
			it->isEnabled = configStation->enabled();
	}
}




void MvMainWindow::handleWaveformQuality(DataModel::WaveformQuality* waveformQuality) {
	std::string stationId = getStationId(waveformQuality);
	StationData* stationData = _stationDataCollection.find(stationId);
	if ( !stationData ) return;

	_qcHandler.handle(stationData, waveformQuality);
}




void MvMainWindow::handleNewArrival(DataModel::Arrival* arrival) {
	_eventDataRepository.addArrival(arrival);
}




void MvMainWindow::handleNewPick(DataModel::Pick* pick) {
	std::string stationId = getStationId(pick);
	StationData* stationData = _stationDataCollection.find(stationId);
	if ( stationData ) {
		_triggerHandler.handle(stationData, pick);
		_eventDataRepository.addPick(pick);
	}
}




void MvMainWindow::handleNewAmplitude(DataModel::Amplitude* amplitude) {
	if ( amplitude->type() != ""snr"" )
		return;

	std::string stationId = getStationId(amplitude);
	StationData* stationData = _stationDataCollection.find(stationId);
#ifdef DEBUG_AMPLITUDES
	std::cerr << ""Delivering Amplitude "" << amplitude->publicID() << "" to station "" << stationId << std::endl;
#endif
	if ( stationData ) {
		_triggerHandler.handle(stationData, amplitude);
		_eventDataRepository.addAmplitude(amplitude);
		updateInfoWidget(amplitude);
	}
}




void MvMainWindow::handleNewOrigin(Seiscomp::DataModel::Origin* origin) {
	_eventDataRepository.addOrigin(origin);
}




void MvMainWindow::handleNewFocalMechanism(Seiscomp::DataModel::FocalMechanism* fm) {
	_eventDataRepository.addFocalMechanism(fm);
}




void MvMainWindow::handleNewMagnitude(Seiscomp::DataModel::Magnitude* magnitude) {
	_eventDataRepository.addMagnitude(magnitude);
}




void MvMainWindow::handleNewEvent(DataModel::Event* event) {
	Gui::OriginSymbol* originSymbol = createOriginSymbolFromEvent(event);

	if ( !originSymbol ) return;

	Gui::TensorSymbol* tensorSymbol = createTensorSymbolFromEvent(event);

	if ( !_eventDataRepository.addEvent(event, originSymbol, tensorSymbol) ) {
		delete originSymbol;
		if ( tensorSymbol ) delete tensorSymbol;
		return;
	}

	_mapWidget->canvas().symbolCollection()->add(originSymbol);
	if ( tensorSymbol )
		_mapWidget->canvas().symbolCollection()->add(tensorSymbol);
}




void MvMainWindow::handleEventUpdate(DataModel::Event* event, EventData* eventData) {
	//std::string eventId = event->publicID();
	//_eventDataRepository.removeEvent(eventId);

	//Gui::OriginSymbol* originSymbol = eventData->originSymbol();
	//_mapWidget->canvas().symbolCollection()->remove(originSymbol);
	removeEventData(eventData);
	handleNewEvent(event);
}




bool MvMainWindow::checkIfEventIsActive(const EventData& eventData) {
	std::string originId = eventData.preferredOriginId();
	DataModel::Origin* origin = _eventDataRepository.findOrigin(originId);

	Core::Time referenceTime = Core::Time::GMT() - _configEventActivityLifeSpan;
	if ( origin->time().value() < referenceTime )
		return false;
	return true;
}




std::vector<StationData*> MvMainWindow::getAssociatedStationsForEvents(std::vector<EventData*>::const_iterator it,
                                                                       std::vector<EventData*>::const_iterator end) {
	std::vector<StationData*> associatedStations;
	for ( ; it != end; it++ ) {
		std::vector<StationData*> tmpAssociatedStations = getAssociatedStationsForEvent(*it);
		associatedStations.insert(associatedStations.end(),
								  tmpAssociatedStations.begin(), tmpAssociatedStations.end());
	}

	return associatedStations;
}




std::vector<StationData*> MvMainWindow::getAssociatedStationsForEvent(const EventData* eventData) {
	std::string preferredOriginId = eventData->preferredOriginId();
	DataModel::Origin* origin = _eventDataRepository.findOrigin(preferredOriginId);

	typedef std::map<std::string, DataModel::PickPtr> PickMap;
	PickMap pickMap;

	DataModel::DatabaseIterator it = SCApp->query()->getPicks(preferredOriginId);
	for ( ; *it; it++ ) {
		DataModel::Pick* pick = DataModel::Pick::Cast(*it);
		pickMap.insert(std::make_pair(pick->publicID(), pick));
	}

	std::vector<StationData*> associatedStations;
	for ( size_t i = 0; i < origin->arrivalCount(); i++ ) {
		DataModel::Arrival* arrival = origin->arrival(i);
		if ( !arrival ) {
			continue;
		}

		std::string arrivalPickId = arrival->pickID();
		PickMap::iterator it = pickMap.find(arrivalPickId);
		if ( it == pickMap.end() ) continue;

		DataModel::Pick* pick = it->second.get();
		std::string stationId = getStationId(pick);
		StationData* stationData = _stationDataCollection.find(stationId);
		if ( stationData )
			associatedStations.push_back(stationData);
	}

	return associatedStations;
}




std::vector<EventData*> MvMainWindow::getActiveEvents() {
	std::vector<EventData*> activeEvents;
	EventDataRepository::event_iterator it = _eventDataRepository.eventsBegin();
	for ( ; it != _eventDataRepository.eventsEnd(); it++ ) {
		if ( it->isActive() )
			activeEvents.push_back(&(*it));
	}

	return activeEvents;
}




bool MvMainWindow::updateEventActivityStatus() {
	bool hasEventStatusChanged = false;

	EventDataRepository::event_iterator it = _eventDataRepository.eventsBegin();
	for ( ; it != _eventDataRepository.eventsEnd(); it++ ) {
		bool wasEventActive = it->isActive();
		bool isEventActive = checkIfEventIsActive(*it);
		it->setActive(isEventActive);

		if ( wasEventActive != isEventActive )
			hasEventStatusChanged = true;
	}

	return hasEventStatusChanged;
}




void MvMainWindow::updateStationsAssociatedStatus() {
	std::vector<StationData*> associatedStations;
	StationDataCollection::iterator stationDataIt = _stationDataCollection.begin();
	for ( ; stationDataIt != _stationDataCollection.end(); stationDataIt++ ) {
		if ( stationDataIt->isAssociated )
			associatedStations.push_back(&(*stationDataIt));
	}

	std::vector<EventData*> activeEvents = getActiveEvents();
	std::vector<StationData*> currentAssociatedStations = getAssociatedStationsForEvents(activeEvents.begin(),
	                                                                                     activeEvents.end());

	std::sort(associatedStations.begin(), associatedStations.end());
	std::sort(currentAssociatedStations.begin(), currentAssociatedStations.end());

	std::vector<StationData*> stationsToBeDeassociated;
	std::set_difference(associatedStations.begin(),
	                    associatedStations.end(),
	                    currentAssociatedStations.begin(),
	                    currentAssociatedStations.end(),
	                    std::back_inserter(stationsToBeDeassociated));

	std::vector<StationData*>::iterator it = stationsToBeDeassociated.begin();
	for ( ; it != stationsToBeDeassociated.end(); it++ )
		(*it)->resetTriggerRelatedData();

	it = currentAssociatedStations.begin();
	for ( ; it != currentAssociatedStations.end(); it++ ) {
		(*it)->isAssociated = true;
	}
}




void MvMainWindow::selectStations(const EventData* eventData, bool isSelected) {
	std::vector<StationData*> associatedStations = getAssociatedStationsForEvent(eventData);
	std::vector<StationData*>::iterator it = associatedStations.begin();
	for ( ; it != associatedStations.end(); it++ )
		(*it)->isSelected = isSelected;
}




void MvMainWindow::showOriginSymbols(bool val) {
	EventDataRepository::event_iterator it = _eventDataRepository.eventsBegin();
	for ( ; it != _eventDataRepository.eventsEnd(); it++ ) {
		if ( it->originSymbol()->TypeInfo() == Gui::OriginSymbol::TypeInfo() )
			it->originSymbol()->setVisible(val);
		if ( it->tensorSymbol() != NULL )
			it->tensorSymbol()->setVisible(val);
	}
}




void MvMainWindow::removeExpiredEvents() {
	while ( true ) {
		EventData* expiredEvent = _eventDataRepository.findNextExpiredEvent();
		if ( !expiredEvent ) break;
		removeEventData(expiredEvent);
	}
}




void MvMainWindow::removeEventData(const EventData* eventData) {
    Gui::OriginSymbol* originSymbol = eventData->originSymbol();
	Gui::TensorSymbol* tensorSymbol = eventData->tensorSymbol();

	_mapWidget->canvas().symbolCollection()->remove(originSymbol);
	if ( tensorSymbol )
		_mapWidget->canvas().symbolCollection()->remove(tensorSymbol);

	std::string eventId = eventData->id();
	_eventDataRepository.removeEvent(eventId);
}




bool MvMainWindow::isInDisplayMode() const {
	return _displayMode != NONE && _displayMode != DisplayModeCount;
}




void MvMainWindow::updateEventData() {
	bool updateNeeded = hasEventCountChanged(_eventDataRepository) ||
	                    updateEventActivityStatus();

	if ( updateNeeded ) {
		updateEventWidget();
		updateStationsAssociatedStatus();
	}

	if ( areOriginSymbolsVisible() )
		updateOriginSymbolDisplay();
}




void MvMainWindow::updateEventWidget() {
	if ( !_eventTableWidgetRef ) return;

	_eventTableWidgetRef->removeEventTableEntries();

	std::vector<std::string> eventInfo;
	EventDataRepository::event_iterator eventDataIt = _eventDataRepository.eventsBegin();
	for ( ; eventDataIt != _eventDataRepository.eventsEnd(); eventDataIt++ ) {
		std::string preferredOriginId = eventDataIt->object()->preferredOriginID();
		DataModel::Origin* origin = _eventDataRepository.findOrigin(preferredOriginId);
		if ( !origin ) {
			SEISCOMP_ERROR(""Could not get preferred origin %s for event %s from database"",
			               preferredOriginId.c_str(), eventDataIt->id().c_str());
			continue;
		}

		EventTableWidget::RowData rowData;
		rowData.setActive(eventDataIt->isActive());
		rowData.setSelected(eventDataIt->isSelected());

		std::string preferredMagnitudeId = eventDataIt->object()->preferredMagnitudeID();
		DataModel::Magnitude* magnitude= _eventDataRepository.findMagnitude(preferredMagnitudeId);
		if ( magnitude )
			addEventWidgetRowData(rowData, magnitude);
		addEventWidgetRowData(rowData, *eventDataIt, origin);

		_eventTableWidgetRef->addRow(rowData);
	}
}




void MvMainWindow::updateInfoWidget(StationData* stationData) {
	if ( StationInfoWidgetRegistry::Instance()->count() == 0 ) return;

	std::string stationId = stationData->id;
	StationInfoWidget* infoWidget = StationInfoWidgetRegistry::Instance()->find(stationId);
	if ( !infoWidget ) return;

	setInfoWidgetContent(infoWidget, stationData);
	infoWidget->updateContent();
}




void MvMainWindow::updateInfoWidget(const DataModel::Pick* pick) {
	if ( StationInfoWidgetRegistry::Instance()->count() == 0 ) return;

	std::string stationId = getStationId(pick);
	StationInfoWidget* infoWidget = StationInfoWidgetRegistry::Instance()->find(stationId);
	if ( !infoWidget ) return;

	Core::Time time = pick->time();
	std::string phaseHint = pick->phaseHint().code();
	infoWidget->addRecordMarker(time, phaseHint);

}




void MvMainWindow::updateInfoWidget(const DataModel::Amplitude* amplitude) {
	if ( StationInfoWidgetRegistry::Instance()->count() == 0 ) return;

	std::string stationId = getStationId(amplitude);
	StationInfoWidget* infoWidget = StationInfoWidgetRegistry::Instance()->find(stationId);
	if ( !infoWidget ) return;

	setInfoWidgetContent(infoWidget, amplitude);
	infoWidget->updateContent();
}




void MvMainWindow::updateInfoWidget(const DataModel::Event* event) {
	if ( EventInfoWidgetRegistry::Instance()->count() == 0 ) return;

	std::string eventId = event->publicID();
	OriginInfoWidget* infoWidget = EventInfoWidgetRegistry::Instance()->find(eventId);
	if ( !infoWidget ) return;

	std::string originId = event->preferredOriginID();
	DataModel::Origin* origin = _eventDataRepository.findOrigin(originId);

	setInfoWidgetContent(infoWidget, origin, event->preferredMagnitudeID());
	infoWidget->updateContent();
}




Gui::OriginSymbol* MvMainWindow::createOriginSymbolFromEvent(DataModel::Event* event) {
	DataModel::Origin *origin = _eventDataRepository.findOrigin(event->preferredOriginID());
	if ( !origin ) {
		SEISCOMP_ERROR(""Could not get preferred origin %s for event %s"",
		               event->preferredOriginID().c_str(),
		               event->publicID().c_str());
		return NULL;
	}

	Gui::TTDecorator *ttDecorator = new Gui::TTDecorator(&_mapWidget->canvas());
	ttDecorator->setDepth(origin->depth());
	ttDecorator->setOriginTime(origin->time());
	ttDecorator->setLatitude(origin->latitude());
	ttDecorator->setLongitude(origin->longitude());

	double magnitudeValue = 0.0;
	DataModel::Magnitude *magnitude= _eventDataRepository.findMagnitude(event->preferredMagnitudeID());
	if ( magnitude )
		magnitudeValue = magnitude->magnitude().value();

	ttDecorator->setPreferredMagnitudeValue(magnitudeValue);
	ttDecorator->setVisible(_ui.showWaveformPropagationAction->isChecked());

	Gui::OriginSymbol *originSymbol = new Gui::OriginSymbol(ttDecorator);
	originSymbol->setLatitude(origin->latitude());
	originSymbol->setLongitude(origin->longitude());
	originSymbol->setID(event->publicID());
	originSymbol->setDepth(origin->depth());
	originSymbol->setPreferredMagnitudeValue(magnitudeValue);
	originSymbol->setPriority(Gui::Map::Symbol::MEDIUM);

	return originSymbol;
}


Seiscomp::Gui::TensorSymbol* MvMainWindow::createTensorSymbolFromEvent(Seiscomp::DataModel::Event* event) {
	if ( event->preferredFocalMechanismID().empty() )
		return NULL;

	DataModel::FocalMechanism *fm = _eventDataRepository.findFocalMechanism(event->preferredFocalMechanismID());
	if ( !fm )
		return NULL;

	if ( fm->momentTensorCount() == 0 )
		SCApp->query()->loadMomentTensors(fm);

	const DataModel::NodalPlane *np = NULL;
	try { np = &(fm->nodalPlanes().nodalPlane1()); }
	catch ( Core::ValueException& ) {}

	if ( np == NULL )
		return NULL;

	DataModel::Origin *origin = NULL;
	DataModel::MomentTensor *mt = NULL;
	DataModel::Magnitude *magnitude = NULL;

	double magnitudeValue = 0.0;

	if ( fm->momentTensorCount() > 0 ) {
		mt = fm->momentTensor(0);
		origin = _eventDataRepository.findOrigin(mt->derivedOriginID());
		magnitude= _eventDataRepository.findMagnitude(mt->momentMagnitudeID());
	}

	if ( magnitude == NULL )
		magnitude = _eventDataRepository.findMagnitude(event->preferredMagnitudeID());

	if ( origin == NULL )
		origin = _eventDataRepository.findOrigin(fm->triggeringOriginID());

	if ( origin == NULL )
		origin = _eventDataRepository.findOrigin(event->preferredOriginID());

	double depth = 10;
	try { depth = origin->depth().value(); }
	catch ( ... ) {}

	if ( magnitude )
		magnitudeValue = magnitude->magnitude().value();

	Math::Tensor2Sd tensor;
	Math::NODAL_PLANE plane;
	plane.str = np->strike();
	plane.dip = np->dip();
	plane.rake = np->rake();
	Math::np2tensor(plane, tensor);

	Gui::TensorSymbol *tensorSymbol = new Gui::TensorSymbol(tensor);

	int size;
	if ( magnitudeValue > 0 )
		size = std::max(SCScheme.map.originSymbolMinSize, int(4.9 * (magnitudeValue - 1.2)));
	else
		size = SCScheme.map.originSymbolMinSize;

	tensorSymbol->setSize(QSize(size*3/2,size*3/2));
	tensorSymbol->setShadingEnabled(true);
	tensorSymbol->setPosition(QPointF(origin->longitude(), origin->latitude()));
	tensorSymbol->setTColor(SCScheme.colors.originSymbol.depth.gradient.colorAt(depth, SCScheme.colors.originSymbol.depth.discrete));
	tensorSymbol->setOffset(QPoint(-16,-32));
	tensorSymbol->setDrawConnectorEnabled(true);
	tensorSymbol->setPriority(Gui::Map::Symbol::HIGH);

	return tensorSymbol;
}



void MvMainWindow::showSearchWidget() {
	SearchWidget* tmp = SearchWidget::Create();
	if ( !tmp ) return;

	_searchWidgetRef = tmp;

	connect(_searchWidgetRef, SIGNAL(stationSelected()), this, SLOT(markSearchWidgetResults()));
	connect(_searchWidgetRef, SIGNAL(destroyed()), this, SLOT(searchWidgetClosed()));

	StationDataCollection::iterator it = _stationDataCollection.begin();
	for ( ; it != _stationDataCollection.end(); it ++ )
		_searchWidgetRef->addStationName(it->id);

	int offset = 20;
	_searchWidgetRef->move(pos().x() + offset, pos().y() + offset);
	_searchWidgetRef->show();
}




void MvMainWindow::markSearchWidgetResults() {
	if ( _searchWidgetRef->matches().empty() )
		return;

	std::string idOfFirstMatch = _searchWidgetRef->matches().front();

	Gui::Map::SymbolCollection::iterator it = _mapWidget->canvas().symbolCollection()->begin();
	for ( ; it != _mapWidget->canvas().symbolCollection()->end(); it++ ) {
		Gui::Map::Symbol* mapSymbol = *it;

		if ( mapSymbol->typeInfo() == MvStationSymbol::TypeInfo() ) {
			SearchWidget::Matches::const_iterator found = std::find(_searchWidgetRef->matches().begin(),
			                                                        _searchWidgetRef->matches().end(),
			                                                        mapSymbol->id());
			if ( found != _searchWidgetRef->matches().end() ) {
				mapSymbol->setVisible(true);
				if ( idOfFirstMatch == mapSymbol->id() )
					_mapWidget->canvas().centerMap(QPoint(static_cast<MvStationSymbol*>(mapSymbol)->x(),
					                             static_cast<MvStationSymbol*>(mapSymbol)->y()));
			}
			else {
				mapSymbol->setVisible(false);
			}
		}
		else if ( mapSymbol->typeInfo() == Gui::OriginSymbol::TypeInfo() ) {
			mapSymbol->setVisible(false);
		}
	}
}




void MvMainWindow::searchWidgetClosed() {
	Gui::Map::SymbolCollection::iterator it = _mapWidget->canvas().symbolCollection()->begin();
	for ( ; it != _mapWidget->canvas().symbolCollection()->end(); it++ ) {
		Gui::Map::Symbol* mapSymbol = *it;

		if ( mapSymbol->typeInfo() == MvStationSymbol::TypeInfo() )
			mapSymbol->setVisible(true);
	}

	if ( areOriginSymbolsVisible() )
		updateOriginSymbolDisplay();
}




void MvMainWindow::handleNewRecord(Seiscomp::Record* record) {
	Seiscomp::RecordPtr recordPtr(record);

	std::string id = getStationId(record);

	StationData* stationData = _stationDataCollection.find(id);
	if ( stationData )
		_recordHandler.handle(stationData, record);
}




void MvMainWindow::handleNewMessage(Core::Message* message) {
	Core::DataMessage* dataMessage = Core::DataMessage::Cast(message);
	if ( dataMessage ) {
		Core::DataMessage::iterator it = dataMessage->begin();
		for ( ; it != dataMessage->end(); ++it ) {
			DataModel::WaveformQuality* waveformQuality = DataModel::WaveformQuality::Cast(*it);
			if ( waveformQuality ) {
				handleWaveformQuality(waveformQuality);

				std::string stationId = getStationId(waveformQuality);
				StationData* stationData = _stationDataCollection.find(stationId);
				if ( stationData )
					updateInfoWidget(stationData);
			}
		}
	}

	DataModel::NotifierMessage* notifierMessage = DataModel::NotifierMessage::Cast(message);
	if ( !notifierMessage ) return;

	DataModel::NotifierMessage::iterator notifierIt = notifierMessage->begin();
	for ( ; notifierIt != notifierMessage->end(); ++notifierIt ) {
		DataModel::Object* object = (*notifierIt)->object();

		DataModel::ConfigStation* configStation = DataModel::ConfigStation::Cast((*notifierIt)->object());
		if ( configStation ) {
			bool processData = SCApp->configModule() &&
			                   SCApp->configModule()->publicID() == (*notifierIt)->parentID();
			if ( processData ) {
				handleNewConfigStation(configStation);
				continue;
			}
		}

		DataModel::Arrival* arrival = DataModel::Arrival::Cast(object);
		if ( arrival ) {
			handleNewArrival(arrival);
			continue;
		}

		DataModel::Pick* pick = DataModel::Pick::Cast(object);
		if ( pick ) {
			handleNewPick(pick);
			updateInfoWidget(pick);
			continue;
		}

		DataModel::Amplitude* amplitude = DataModel::Amplitude::Cast(object);
		if ( amplitude ) {
			handleNewAmplitude(amplitude);
			updateInfoWidget(amplitude);
			continue;
		}

		DataModel::Magnitude* magnitude = DataModel::Magnitude::Cast(object);
		if ( magnitude ) {
			handleNewMagnitude(magnitude);
			continue;
		}

		DataModel::Origin* origin = DataModel::Origin::Cast(object);
		if ( origin ) {
			handleNewOrigin(origin);
			continue;
		}

		DataModel::FocalMechanism* fm = DataModel::FocalMechanism::Cast(object);
		if ( fm ) {
			handleNewFocalMechanism(fm);
			continue;
		}

		DataModel::Event* event = DataModel::Event::Cast(object);
		if ( event ) {
			std::string eventId = event->publicID();
			EventData* eventData = _eventDataRepository.findEvent(eventId);

			if ( isFakeEvent(event) ||
			     (*notifierIt)->operation() == DataModel::OP_REMOVE ) {
				if ( eventData )  {
					removeEventData(eventData);
					updateEventWidget();
				}
				continue;
			}

			SCApp->query()->loadEventDescriptions(event);

			bool handleAsEventUpdate = eventData;
			if ( handleAsEventUpdate ) {
				std::cerr << ""Event update for:"" << event->publicID()  << std::endl;

				handleEventUpdate(event, eventData);
				updateInfoWidget(event);
			}
			else {
				std::cerr << ""New event: "" << event->publicID() << std::endl;
				handleNewEvent(event);
			}

			if ( _ui.centerOriginForLatestEventAction->isChecked() )
				centerOriginForLatestEvent();

			removeExpiredEvents();
		}
	}
}




void MvMainWindow::showInfoWidget() {
	QAction* contextMenuAction = static_cast<QAction*>(sender());

	QVariant variant = contextMenuAction->data();
	void* data = variant.value<void*>();
	Gui::Map::Symbol* mapSymbol = static_cast<Gui::Map::Symbol*>(data);

	std::string mapSymbolId = mapSymbol->id();

	if ( mapSymbol->typeInfo() == MvStationSymbol::TypeInfo() ) {
		StationInfoWidget* infoWidget = new StationInfoWidget(mapSymbolId, this);

		StationData* stationData = _stationDataCollection.find(mapSymbolId);

		configureInfoWidgetForRecordAcquisition(infoWidget,
  		                                        _configStationPickCacheLifeSpan,
		                                        _configStationRecordFilterStr);

		setInfoWidgetContent(infoWidget, stationData->stationRef.get());

		if ( stationData->qcGlobalStatus != QCStatus::NOT_SET )
			setInfoWidgetContent(infoWidget, stationData);

		StationData::TPickCollection::iterator it = stationData->tPickCache.begin();
		for ( ; it != stationData->tPickCache.end(); it++ ) {
			Core::Time time = (*it)->time();
			std::string phaseHint = (*it)->phaseHint().code();
			infoWidget->addRecordMarker(time, phaseHint);
		}

		if ( stationData->tAmplitudeTime != Core::Time::Null )
			setInfoWidgetContent(infoWidget, stationData->tAmplitude.get());

		::showInfoWidget(infoWidget);
	}
	else if ( mapSymbol->typeInfo() == Gui::OriginSymbol::TypeInfo() ) {
		OriginInfoWidget* infoWidget = new OriginInfoWidget(mapSymbolId, this);

		std::string eventId = mapSymbol->id();
		EventData* eventData = _eventDataRepository.findEvent(eventId);

		std::string preferredOriginId = eventData->object()->preferredOriginID();
		DataModel::Origin* origin = _eventDataRepository.findOrigin(preferredOriginId);

		setInfoWidgetContent(infoWidget, origin, eventData->object()->preferredMagnitudeID());
		::showInfoWidget(infoWidget);
	}
}




void MvMainWindow::updateOriginSymbolDisplay() {
	bool areHistoricOriginsVisible = _ui.showHistoricOriginsAction->isChecked();
	EventData* latestEventData = _eventDataRepository.findLatestEvent();

	EventDataRepository::event_iterator it = _eventDataRepository.eventsBegin();
	for ( ; it != _eventDataRepository.eventsEnd(); it++ ) {
		EventData& eventData = *it;
		Gui::OriginSymbol* originSymbol = eventData.originSymbol();
		Gui::TensorSymbol* tensorSymbol = eventData.tensorSymbol();

		bool eventIsActive = eventData.isActive();
		bool eventIsSelected = eventData.isSelected();

		bool isLatestEventAndHistoricOriginsAreVisible = areHistoricOriginsVisible &&
		                                                 eventData.id() == latestEventData->id();
		bool isLatestEventAndHistoricOriginsAreNotVisible = !areHistoricOriginsVisible &&
		                                                    eventData.id() == latestEventData->id();

		if ( eventIsActive || isLatestEventAndHistoricOriginsAreVisible ) {
			originSymbol->setVisible(true);
			if ( tensorSymbol ) tensorSymbol->setVisible(true);
			originSymbol->setFilled(false);
			if ( ApplicationStatus::Instance()->isTriggering() )
				originSymbol->setFilled(true);
		}
		else if ( eventIsSelected || isLatestEventAndHistoricOriginsAreNotVisible ) {
			originSymbol->setVisible(true);
			if ( tensorSymbol ) tensorSymbol->setVisible(true);
			originSymbol->setFilled(false);
		}
		else {
			originSymbol->setVisible(areHistoricOriginsVisible);
			if ( tensorSymbol ) tensorSymbol->setVisible(areHistoricOriginsVisible);
			originSymbol->setFilled(false);
		}
	}
}




void MvMainWindow::setWaveformPropagationVisible(bool val) {
	Gui::Map::SymbolCollection::iterator it = _mapWidget->canvas().symbolCollection()->begin();
	for ( ; it != _mapWidget->canvas().symbolCollection()->end(); it++ ) {
		Gui::Map::Symbol* mapSymbol = *it;
		if ( Gui::OriginSymbol::TypeInfo() == mapSymbol->typeInfo() ) {
			Gui::Map::Decorator* decorator = mapSymbol->decorator();
			if ( decorator )
				decorator->setVisible(val);
		}
	}
}




void MvMainWindow::centerOriginForLatestEvent() {
	EventData* eventData = _eventDataRepository.findLatestEvent();
	if ( !eventData ) return;

	std::string eventId = eventData->id();
	centerOriginForEvent(eventId.c_str());
}




void MvMainWindow::centerOriginForEvent(const QString& id) {
	EventData* eventData = _eventDataRepository.findEvent(id.toStdString());

	std::string preferredOriginId = eventData->object()->preferredOriginID();
	DataModel::Origin* origin = _eventDataRepository.findOrigin(preferredOriginId);

	_mapWidget->canvas().setMapCenter(QPointF(origin->longitude(), origin->latitude()));
}




void MvMainWindow::resetStationData() {
	StationDataCollection::iterator it = _stationDataCollection.begin();
	for ( ; it != _stationDataCollection.end(); it++ )
		it->reset();
}



void MvMainWindow::selectStationsForEvent(const QString& eventId) {
	deselectStations();

	EventData* eventData = _eventDataRepository.findEvent(eventId.toStdString());
	selectStations(eventData);
}




void MvMainWindow::deselectStations() {
	StationDataCollection::iterator it = _stationDataCollection.begin();
	for ( ; it != _stationDataCollection.end(); it++ )
		it->isSelected = false;
}




void MvMainWindow::selectEvent(const QString& eventId) {
	deselectEvents();

	EventData* eventData = _eventDataRepository.findEvent(eventId.toStdString());
	eventData->setSelected(true);
}




void MvMainWindow::deselectEvents() {
	EventDataRepository::event_iterator eventDataIt = _eventDataRepository.eventsBegin();
	for ( ; eventDataIt != _eventDataRepository.eventsEnd(); eventDataIt++ )
		eventDataIt->setSelected(false);
}




void MvMainWindow::setStationIdVisible(bool val) {
	for ( StationDataCollection::iterator it = _stationDataCollection.begin();
			it	!= _stationDataCollection.end(); it++ ) {
		it->stationSymbolRef->setIdDrawingEnabled(val);
	}

	_mapWidget->update();
}




void MvMainWindow::setStationChannelCodesVisible(bool val) {
	for ( StationDataCollection::iterator it = _stationDataCollection.begin();
			it	!= _stationDataCollection.end(); it++ ) {
		it->stationSymbolRef->setDrawFullID(val);
	}

	_mapWidget->update();
}
",16357,True,3090.899414004514,median
"CLASS ltcl_test DEFINITION FOR TESTING
  DURATION SHORT
  RISK LEVEL HARMLESS FINAL.

  PUBLIC SECTION.
  PROTECTED SECTION.
  PRIVATE SECTION.
    DATA mo_cut TYPE REF TO ycl_advent2020_day09.
    DATA m_input TYPE string_table.

    METHODS setup.
    METHODS given_the_example.
    METHODS given_the_input.

    METHODS part_one_example FOR TESTING.
    METHODS part_one_input FOR TESTING.

    METHODS part_two_example FOR TESTING.
    METHODS part_two_input FOR TESTING.


ENDCLASS.

CLASS ltcl_test IMPLEMENTATION.

  METHOD setup.
    mo_cut = NEW #( ).
  ENDMETHOD.

  METHOD part_one_example.
    given_the_example( ).
    DATA(act) = mo_cut->solve_part_one( input = m_input preamble_len = 5 )-number.
    cl_abap_unit_assert=>assert_equals( exp = 127 act = act ).
  ENDMETHOD.

  METHOD part_one_input.
    given_the_input( ).
    DATA(act) = mo_cut->solve_part_one( input = m_input preamble_len = 25 )-number.

    cl_abap_unit_assert=>assert_equals( exp = 1212510616 act = act ).
  ENDMETHOD.

  METHOD part_two_example.
    given_the_example( ).
    DATA(act) = mo_cut->solve_part_two( input = m_input preamble_len = 5 ).
    cl_abap_unit_assert=>assert_equals( exp = 62 act = act ).
  ENDMETHOD.

  METHOD part_two_input.
    given_the_input( ).
    DATA(act) = mo_cut->solve_part_two( input = m_input preamble_len = 25 ).
    cl_abap_unit_assert=>assert_equals( exp = 171265123 act = act ).
  ENDMETHOD.

  METHOD given_the_example.
    m_input = VALUE #(
      ( |35| )
      ( |20| )
      ( |15| )
      ( |25| )
      ( |47| )
      ( |40| )
      ( |62| )
      ( |55| )
      ( |65| )
      ( |95| )
      ( |102| )
      ( |117| )
      ( |150| )
      ( |182| )
      ( |127| )
      ( |219| )
      ( |299| )
      ( |277| )
      ( |309| )
      ( |576| )
    ).
  ENDMETHOD.

  METHOD given_the_input.
    m_input = VALUE #(
      ( |3| )
      ( |48| )
      ( |30| )
      ( |21| )
      ( |18| )
      ( |50| )
      ( |9| )
      ( |37| )
      ( |5| )
      ( |31| )
      ( |17| )
      ( |39| )
      ( |14| )
      ( |45| )
      ( |27| )
      ( |23| )
      ( |2| )
      ( |4| )
      ( |19| )
      ( |35| )
      ( |10| )
      ( |32| )
      ( |33| )
      ( |28| )
      ( |7| )
      ( |34| )
      ( |11| )
      ( |6| )
      ( |8| )
      ( |12| )
      ( |54| )
      ( |13| )
      ( |9| )
      ( |15| )
      ( |16| )
      ( |60| )
      ( |64| )
      ( |17| )
      ( |14| )
      ( |18| )
      ( |20| )
      ( |23| )
      ( |24| )
      ( |25| )
      ( |19| )
      ( |21| )
      ( |26| )
      ( |22| )
      ( |27| )
      ( |46| )
      ( |28| )
      ( |29| )
      ( |30| )
      ( |31| )
      ( |32| )
      ( |38| )
      ( |33| )
      ( |37| )
      ( |45| )
      ( |63| )
      ( |34| )
      ( |35| )
      ( |39| )
      ( |51| )
      ( |40| )
      ( |41| )
      ( |43| )
      ( |60| )
      ( |44| )
      ( |47| )
      ( |52| )
      ( |58| )
      ( |62| )
      ( |55| )
      ( |57| )
      ( |59| )
      ( |61| )
      ( |64| )
      ( |100| )
      ( |65| )
      ( |95| )
      ( |73| )
      ( |71| )
      ( |69| )
      ( |103| )
      ( |74| )
      ( |82| )
      ( |83| )
      ( |108| )
      ( |147| )
      ( |160| )
      ( |87| )
      ( |117| )
      ( |91| )
      ( |112| )
      ( |107| )
      ( |176| )
      ( |114| )
      ( |116| )
      ( |148| )
      ( |120| )
      ( |125| )
      ( |133| )
      ( |190| )
      ( |134| )
      ( |152| )
      ( |205| )
      ( |183| )
      ( |156| )
      ( |216| )
      ( |199| )
      ( |202| )
      ( |174| )
      ( |211| )
      ( |219| )
      ( |194| )
      ( |178| )
      ( |198| )
      ( |203| )
      ( |223| )
      ( |221| )
      ( |354| )
      ( |418| )
      ( |236| )
      ( |258| )
      ( |323| )
      ( |259| )
      ( |267| )
      ( |286| )
      ( |469| )
      ( |308| )
      ( |489| )
      ( |330| )
      ( |439| )
      ( |372| )
      ( |368| )
      ( |392| )
      ( |527| )
      ( |401| )
      ( |611| )
      ( |414| )
      ( |521| )
      ( |419| )
      ( |424| )
      ( |444| )
      ( |457| )
      ( |793| )
      ( |494| )
      ( |495| )
      ( |594| )
      ( |609| )
      ( |702| )
      ( |553| )
      ( |722| )
      ( |700| )
      ( |638| )
      ( |698| )
      ( |773| )
      ( |740| )
      ( |895| )
      ( |1130| )
      ( |815| )
      ( |951| )
      ( |833| )
      ( |838| )
      ( |843| )
      ( |868| )
      ( |1535| )
      ( |1239| )
      ( |1282| )
      ( |952| )
      ( |1578| )
      ( |1398| )
      ( |1794| )
      ( |2496| )
      ( |1725| )
      ( |1360| )
      ( |1293| )
      ( |1336| )
      ( |1378| )
      ( |1671| )
      ( |1438| )
      ( |1513| )
      ( |1635| )
      ( |2895| )
      ( |1648| )
      ( |1653| )
      ( |1681| )
      ( |2203| )
      ( |2491| )
      ( |1711| )
      ( |2671| )
      ( |2191| )
      ( |2617| )
      ( |2234| )
      ( |2245| )
      ( |2776| )
      ( |2629| )
      ( |2653| )
      ( |4306| )
      ( |2731| )
      ( |2774| )
      ( |2714| )
      ( |2816| )
      ( |5288| )
      ( |2951| )
      ( |3073| )
      ( |3148| )
      ( |4139| )
      ( |3301| )
      ( |5492| )
      ( |4282| )
      ( |5847| )
      ( |8038| )
      ( |3902| )
      ( |3945| )
      ( |5264| )
      ( |8578| )
      ( |8412| )
      ( |4479| )
      ( |4874| )
      ( |5592| )
      ( |5505| )
      ( |5367| )
      ( |5445| )
      ( |5488| )
      ( |5530| )
      ( |5665| )
      ( |5767| )
      ( |6449| )
      ( |8789| )
      ( |7203| )
      ( |7093| )
      ( |9967| )
      ( |7246| )
      ( |14243| )
      ( |13050| )
      ( |8424| )
      ( |12691| )
      ( |9433| )
      ( |9450| )
      ( |9353| )
      ( |10144| )
      ( |15649| )
      ( |12734| )
      ( |10241| )
      ( |10812| )
      ( |10855| )
      ( |13954| )
      ( |14234| )
      ( |11432| )
      ( |14191| )
      ( |17097| )
      ( |12216| )
      ( |14873| )
      ( |14296| )
      ( |15517| )
      ( |26882| )
      ( |15670| )
      ( |23596| )
      ( |17777| )
      ( |24440| )
      ( |17857| )
      ( |18786| )
      ( |39113| )
      ( |18803| )
      ( |19497| )
      ( |23028| )
      ( |21053| )
      ( |21096| )
      ( |21667| )
      ( |22287| )
      ( |23071| )
      ( |41164| )
      ( |35634| )
      ( |23648| )
      ( |26407| )
      ( |26512| )
      ( |27089| )
      ( |40885| )
      ( |29813| )
      ( |48756| )
      ( |45298| )
      ( |36766| )
      ( |36563| )
      ( |36580| )
      ( |40470| )
      ( |41784| )
      ( |40550| )
      ( |38300| )
      ( |44124| )
      ( |40593| )
      ( |70698| )
      ( |84717| )
      ( |43383| )
      ( |43954| )
      ( |67195| )
      ( |64198| )
      ( |50055| )
      ( |85689| )
      ( |60228| )
      ( |63173| )
      ( |53601| )
      ( |83933| )
      ( |87082| )
      ( |77236| )
      ( |73143| )
      ( |73329| )
      ( |73346| )
      ( |78347| )
      ( |77130| )
      ( |78850| )
      ( |110283| )
      ( |78893| )
      ( |82254| )
      ( |83976| )
      ( |114652| )
      ( |110578| )
      ( |93438| )
      ( |87337| )
      ( |117250| )
      ( |103656| )
      ( |113228| )
      ( |113829| )
      ( |116774| )
      ( |123401| )
      ( |126744| )
      ( |126930| )
      ( |150273| )
      ( |146472| )
      ( |183721| )
      ( |151490| )
      ( |146675| )
      ( |150476| )
      ( |180786| )
      ( |189176| )
      ( |263449| )
      ( |201166| )
      ( |210212| )
      ( |187632| )
      ( |297560| )
      ( |197094| )
      ( |190993| )
      ( |180775| )
      ( |339652| )
      ( |230002| )
      ( |216884| )
      ( |277017| )
      ( |230603| )
      ( |273877| )
      ( |376808| )
      ( |273216| )
      ( |273402| )
      ( |293147| )
      ( |296948| )
      ( |367360| )
      ( |297151| )
      ( |327450| )
      ( |474568| )
      ( |361561| )
      ( |368407| )
      ( |371768| )
      ( |377869| )
      ( |378625| )
      ( |490761| )
      ( |388087| )
      ( |411378| )
      ( |397659| )
      ( |503819| )
      ( |446886| )
      ( |447487| )
      ( |490100| )
      ( |504005| )
      ( |720703| )
      ( |571028| )
      ( |671772| )
      ( |546618| )
      ( |566549| )
      ( |590095| )
      ( |594099| )
      ( |624601| )
      ( |658712| )
      ( |689011| )
      ( |729968| )
      ( |733329| )
      ( |740175| )
      ( |1030480| )
      ( |756494| )
      ( |766712| )
      ( |785746| )
      ( |799465| )
      ( |809037| )
      ( |1135897| )
      ( |894373| )
      ( |936986| )
      ( |1218700| )
      ( |1246594| )
      ( |1050623| )
      ( |1140717| )
      ( |1471237| )
      ( |1113167| )
      ( |1171219| )
      ( |1156644| )
      ( |1313612| )
      ( |2055631| )
      ( |1763809| )
      ( |1347723| )
      ( |1418979| )
      ( |1463297| )
      ( |1523206| )
      ( |2187124| )
      ( |1661085| )
      ( |1542240| )
      ( |1552458| )
      ( |1722732| )
      ( |1703410| )
      ( |2186520| )
      ( |2007540| )
      ( |2679850| )
      ( |2698884| )
      ( |2163790| )
      ( |2893951| )
      ( |2191340| )
      ( |2253884| )
      ( |2269811| )
      ( |2284386| )
      ( |2327863| )
      ( |2470256| )
      ( |2766702| )
      ( |3070455| )
      ( |2811020| )
      ( |2870929| )
      ( |4890224| )
      ( |2986503| )
      ( |3203325| )
      ( |3094698| )
      ( |3213543| )
      ( |3275190| )
      ( |5837157| )
      ( |3426142| )
      ( |3710950| )
      ( |5364207| )
      ( |4335403| )
      ( |5753205| )
      ( |5569813| )
      ( |4355130| )
      ( |5704971| )
      ( |8664511| )
      ( |5198792| )
      ( |8564225| )
      ( |4612249| )
      ( |9131113| )
      ( |5236958| )
      ( |5577722| )
      ( |8450501| )
      ( |12090653| )
      ( |5857432| )
      ( |17695338| )
      ( |17454860| )
      ( |6416868| )
      ( |9003864| )
      ( |8690533| )
      ( |6701332| )
      ( |7137092| )
      ( |7761545| )
      ( |8947652| )
      ( |8967379| )
      ( |9534195| )
      ( |9553922| )
      ( |9592088| )
      ( |26385871| )
      ( |13618977| )
      ( |13687459| )
      ( |12994524| )
      ( |14141947| )
      ( |9849207| )
      ( |10814680| )
      ( |18299708| )
      ( |15449520| )
      ( |18042589| )
      ( |12274300| )
      ( |12558764| )
      ( |17353633| )
      ( |18559467| )
      ( |13118200| )
      ( |26681983| )
      ( |27136471| )
      ( |13838424| )
      ( |14898637| )
      ( |16709197| )
      ( |22548446| )
      ( |40823930| )
      ( |19383402| )
      ( |19146010| )
      ( |19441295| )
      ( |34282039| )
      ( |24747844| )
      ( |32158717| )
      ( |22843731| )
      ( |20663887| )
      ( |55722567| )
      ( |23088980| )
      ( |24833064| )
      ( |26112724| )
      ( |29912397| )
      ( |36794928| )
      ( |25676964| )
      ( |30471833| )
      ( |36386870| )
      ( |26956624| )
      ( |51285507| )
      ( |39552928| )
      ( |28737061| )
      ( |53723334| )
      ( |38529412| )
      ( |58935316| )
      ( |41989741| )
      ( |38587305| )
      ( |39809897| )
      ( |43752867| )
      ( |45411731| )
      ( |43507618| )
      ( |45496951| )
      ( |45932711| )
      ( |47620511| )
      ( |47922044| )
      ( |48765944| )
      ( |50510028| )
      ( |54414025| )
      ( |52633588| )
      ( |55693685| )
      ( |70709491| )
      ( |57428457| )
      ( |67324366| )
      ( |84462123| )
      ( |82094923| )
      ( |83317515| )
      ( |123343079| )
      ( |89610252| )
      ( |85306848| )
      ( |78397202| )
      ( |80577046| )
      ( |85742608| )
      ( |83562764| )
      ( |88919349| )
      ( |128907230| )
      ( |89440329| )
      ( |91429662| )
      ( |94698655| )
      ( |98130539| )
      ( |100555632| )
      ( |143854354| )
      ( |165454905| )
      ( |178707585| )
      ( |108327273| )
      ( |113122142| )
      ( |186724475| )
      ( |299846617| )
      ( |145721568| )
      ( |158974248| )
      ( |160492125| )
      ( |237151230| )
      ( |174917100| )
      ( |326591559| )
      ( |164139810| )
      ( |170017375| )
      ( |166319654| )
      ( |169305372| )
      ( |221449415| )
      ( |178359678| )
      ( |233294683| )
      ( |180869991| )
      ( |329594715| )
      ( |192829194| )
      ( |241984893| )
      ( |208882905| )
      ( |479136123| )
      ( |254048841| )
      ( |387242583| )
      ( |258843710| )
      ( |687089200| )
      ( |339844239| )
      ( |373022715| )
      ( |356969004| )
      ( |319466373| )
      ( |324631935| )
      ( |375202559| )
      ( |330459464| )
      ( |333445182| )
      ( |350175363| )
      ( |335625026| )
      ( |362134566| )
      ( |809595587| )
      ( |373699185| )
      ( |359229669| )
      ( |500336364| )
      ( |510464706| )
      ( |434814087| )
      ( |450867798| )
      ( |462931746| )
      ( |467726615| )
      ( |615812714| )
      ( |584508305| )
      ( |1006555573| )
      ( |692594030| )
      ( |693165558| )
      ( |644098308| )
      ( |658077117| )
      ( |649925837| )
      ( |829931079| )
      ( |694854695| )
      ( |978191321| )
      ( |663904646| )
      ( |1066293215| )
      ( |709405032| )
      ( |697759592| )
      ( |869694375| )
      ( |732928854| )
      ( |1117652452| )
      ( |943737974| )
      ( |1132573679| )
      ( |961332504| )
      ( |885681885| )
      ( |913799544| )
      ( |930658361| )
      ( |1488008196| )
      ( |1200321019| )
      ( |1293913337| )
      ( |1294024145| )
      ( |1302175425| )
      ( |1341857900| )
      ( |1308002954| )
      ( |1313830483| )
      ( |1344780532| )
      ( |1625237150| )
      ( |1358759341| )
      ( |1407164624| )
      ( |1361664238| )
      ( |1827057484| )
      ( |1430688446| )
      ( |1567453967| )
      ( |1212510616| )
      ( |2269335458| )
      ( |1799481429| )
      ( |2086002904| )
      ( |1816340246| )
      ( |1844457905| )
      ( |2126310160| )
      ( |2114120563| )
      ( |3120970821| )
      ( |2412831635| )
      ( |2559080360| )
      ( |2506423953| )
      ( |2506534761| )
      ( |2837853070| )
      ( |2675494721| )
      ( |2520513570| )
      ( |2526341099| )
      ( |2557291148| )
      ( |2571269957| )
      ( |2619675240| )
      ( |2574174854| )
      ( |3615821675| )
      ( |3247028692| )
      ( |3298513520| )
      ( |3326631179| )
      ( |5201835820| )
      ( |3643939334| )
      ( |6203019694| )
      ( |3930460809| )
      ( |3660798151| )
      ( |5900806033| )
      ( |4240430723| )
      ( |5088326356| )
      ( |4919255588| )
      ( |4919366396| )
      ( |5065615121| )
      ( |5012958714| )
      ( |5027048331| )
      ( |6218114188| )
      ( |5094688424| )
      ( |6142162774| )
      ( |5083632247| )
      ( |5818298649| )
      ( |5190945197| )
      ( |5918188760| )
      ( |9534010435| )
      ( |6545542212| )
      ( |8849827205| )
      ( |6625144699| )
      ( |9244819939| )
      ( |8862633971| )
      ( |7304737485| )
      ( |7591258960| )
      ( |12399425909| )
      ( |7901228874| )
      ( |9159686311| )
      ( |9159797119| )
      ( |9838621984| )
      ( |9932214302| )
      ( |9932325110| )
      ( |10040007045| )
      ( |10096590961| )
      ( |10110680578| )
      ( |15352309084| )
      ( |17483058156| )
      ( |13446900259| )
      ( |14216403659| )
      ( |11009243846| )
      ( |21348129133| )
      ( |12463730972| )
      ( |19199804164| )
      ( |13170686911| )
      ( |16557359001| )
      ( |13929882184| )
      ( |14895996445| )
      ( |19768468457| )
      ( |15492487834| )
      ( |24148617961| )
      ( |17060915185| )
      ( |18319483430| )
      ( |20028916071| )
      ( |37519287594| )
      ( |31186751117| )
      ( |19972332155| )
      ( |21049250891| )
      ( |20136598006| )
      ( |41185848897| )
      ( |21119924424| )
      ( |33984872116| )
      ( |23472974818| )
      ( |28939388093| )
      ( |25905240291| )
      ( |24179930757| )
      ( |25634417883| )
      ( |36260719349| )
      ( |51449169778| )
      ( |43501890889| )
      ( |39797384528| )
      ( |28825878629| )
      ( |62810750745| )
      ( |38965462652| )
      ( |39641105795| )
      ( |84687739786| )
      ( |37197513191| )
      ( |38291815585| )
      ( |40001248226| )
      ( |49814348640| )
      ( |75226182001| )
      ( |40108930161| )
      ( |41256522430| )
      ( |43609572824| )
      ( |44592899242| )
      ( |45299855181| )
      ( |62165959640| )
      ( |60440650106| )
      ( |50085171048| )
      ( |64599880535| )
      ( |53005809386| )
      ( |54460296512| )
      ( |65086597978| )
      ( |79906314689| )
      ( |81901388409| )
      ( |66023391820| )
      ( |67117694214| )
      ( |75489328776| )
      ( |76162975843| )
      ( |76838618986| )
      ( |109192779777| )
      ( |142607022990| )
      ( |112251130688| )
      ( |93114739547| )
      ( |119060177047| )
      ( |81365452591| )
      ( |111323247001| )
      ( |95385026229| )
      ( |88202472066| )
      ( |89892754423| )
      ( |185355755620| )
      ( |136361684921| )
      ( |103090980434| )
      ( |104545467560| )
      ( |120483688332| )
      ( |129168785229| )
      ( |119546894490| )
      ( |169953358533| )
      ( |133141086034| )
      ( |141512720596| )
      ( |142862010806| )
      ( |165041091052| )
      ( |151652304619| )
      ( |153001594829| )
      ( |158204071577| )
      ( |271199199109| )
      ( |391682887441| )
      ( |169567924657| )
      ( |171258207014| )
      ( |339521283190| )
      ( |176750478820| )
      ( |270681505825| )
      ( |543335192060| )
      ( |178095226489| )
      ( |192983734857| )
      ( |207636447994| )
      ( |232259765663| )
      ( |222637874924| )
      ( |224092362050| )
      ( |240030582822| )
      ( |248715679719| )
      ( |252687980524| )
      ( |346318403477| )
      ( |274653806630| )
      ( |309856376196| )
      ( |311205666406| )
      ( |321220229276| )
      ( |426306111249| )
      ( |324259801843| )
      ( |584510182826| )
      ( |340826131671| )
      ( |547157731184| )
      ( |543858104200| )
      ( |766495979124| )
      ( |546897676767| )
      ( |354845705309| )
      ( |523369486349| )
      ( |504189401263| )
      ( |402187588539| )
      ( |433014317679| )
      ( |472808041769| )
      ( |859163989456| )
      ( |446730236974| )
      ( |712043964735| )
      ( |527341787154| )
      ( |620972210107| )
      ( |562544356720| )
      ( |598913608473| )
      ( |585859473036| )
      ( |825409630539| )
      ( |666051371715| )
      ( |930495512512| )
      ( |979911994446| )
      ( |679105507152| )
      ( |827653747078| )
      ( |743013720210| )
      ( |757033293848| )
      ( |990588341174| )
      ( |787860022988| )
      ( |801575942283| )
      ( |1507253781600| )
      ( |835201906218| )
      ( |1364120299003| )
      ( |848917825513| )
      ( |1206831683143| )
      ( |919538278743| )
      ( |1514307413370| )
      ( |974072024128| )
      ( |1089886143874| )
      ( |1148313997261| )
      ( |1161457965193| )
      ( |1148403829756| )
      ( |1918491259041| )
      ( |1264964980188| )
      ( |1656639712889| )
      ( |1345156878867| )
      ( |1422119227362| )
      ( |2180903707271| )
      ( |1436138801000| )
      ( |2355677079743| )
      ( |1500047014058| )
      ( |1544893316836| )
      ( |2818097678082| )
      ( |2368289648336| )
      ( |1650493767796| )
      ( |1754740184961| )
      ( |2493470876128| )
      ( |2063958168002| )
      ( |1768456104256| )
      ( |2576177991632| )
      ( |2080996243936| )
      ( |2950446214370| )
      ( |2526024944874| )
      ( |2238289973630| )
      ( |2296717827017| )
      ( |2413368809944| )
      ( |2648450843814| )
      ( |3268503118314| )
      ( |2845203892925| )
      ( |4248211061089| )
      ( |2781295679867| )
      ( |2858258028362| )
      ( |4018783416132| )
      ( |2936185815058| )
      ( |4704641919314| )
      ( |3313349421092| )
      ( |3195387084632| )
      ( |3405233952757| )
      ( |3418949872052| )
      ( |3523196289217| )
      ( |5081805525348| )
      ( |4494365053880| )
      ( |3832414272258| )
      ( |5258572702869| )
      ( |5232903642075| )
      ( |8952852980403| )
      ( |6508736505724| )
      ( |7555290529886| )
      ( |7807714474972| )
      ( |5584636658872| )
      ( |8780023743504| )
      ( |5794443843420| )
      ( |6171607449454| )
      ( |6200245551919| )
      ( |10666442184220| )
      ( |5639553708229| )
      ( |8638137594832| )
      ( |9366994534086| )
      ( |6355135687110| )
      ( |6600621037389| )
      ( |10341150777982| )
      ( |8834940792861| )
      ( |7913314925932| )
      ( |7355610561475| )
      ( |8326779326138| )
      ( |9417050931130| )
      ( |13979321924426| )
      ( |13199408806344| )
      ( |10491476344944| )
      ( |10817540300947| )
      ( |16541396329901| )
      ( |11224190367101| )
      ( |12800866589308| )
      ( |11379080502292| )
      ( |11433997551649| )
      ( |11811161157683| )
      ( |11839799260148| )
      ( |11994689395339| )
      ( |13552868634161| )
      ( |18166296844793| )
      ( |12240174745618| )
      ( |12955756724499| )
      ( |18579800928576| )
      ( |21112723732276| )
      ( |16748255718793| )
      ( |16772661492605| )
      ( |15682389887613| )
      ( |15268925487407| )
      ( |17743830257268| )
      ( |28588054978941| )
      ( |20641241298231| )
      ( |26780188513734| )
      ( |22331275605092| )
      ( |40497572449885| )
      ( |23674172297267| )
      ( |23428686946988| )
      ( |27522189147761| )
      ( |23245158709332| )
      ( |22813078053941| )
      ( |23273796811797| )
      ( |28583822650288| )
      ( |29704012443292| )
      ( |27922564633231| )
      ( |40823997395906| )
      ( |43454319352172| )
      ( |25195931470117| )
      ( |30699586981767| )
      ( |30951315375020| )
      ( |60655327818312| )
      ( |32455051380218| )
      ( |43204579035374| )
      ( |33012755744675| )
      ( |55728848192015| )
      ( |49229296277172| )
      ( |42972516903323| )
      ( |59792944258409| )
      ( |45144353659033| )
      ( |52012509597276| )
      ( |50950876094749| )
      ( |46058236763273| )
      ( |57226201591053| )
      ( |46086874865738| )
      ( |48441090179449| )
      ( |48009009524058| )
      ( |84028576431280| )
      ( |53118496103348| )
      ( |80464060904276| )
      ( |105659992374393| )
      ( |56147246845137| )
      ( |57650982850335| )
      ( |94985026500599| )
      ( |61650902356787| )
      ( |63406366755238| )
      ( |78541926245956| )
      ( |79099630610413| )
      ( |98959885618807| )
      ( |75985272647998| )
      ( |130050506705162| )
      ( |88116870562356| )
      ( |89030753666596| )
      ( |91202590422306| )
      ( |93585443838482| )
    ).
  ENDMETHOD.

ENDCLASS.
",13484,True,4999.495626881945,median
"/* Copyright 2019 Google LLC

Licensed under the Apache License, Version 2.0 (the ""License"");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an ""AS IS"" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#ifndef _WIN32
#include ""ml_metadata/metadata_store/rdbms_metadata_access_object.h""

#endif

#include <string>
#include <vector>

#include ""google/protobuf/struct.pb.h""
#include ""google/protobuf/descriptor.h""
#include ""google/protobuf/util/json_util.h""
#include ""google/protobuf/util/message_differencer.h""
#include ""absl/container/flat_hash_map.h""
#include ""absl/container/flat_hash_set.h""
#include ""absl/memory/memory.h""
#include ""absl/strings/escaping.h""
#include ""absl/strings/match.h""
#include ""absl/strings/numbers.h""
#include ""absl/strings/str_cat.h""
#include ""absl/strings/str_join.h""
#include ""absl/strings/str_replace.h""
#include ""absl/strings/strip.h""
#include ""absl/strings/substitute.h""
#include ""absl/time/clock.h""
#include ""absl/time/time.h""
// clang-format off
#ifdef _WIN32
#include ""ml_metadata/metadata_store/rdbms_metadata_access_object.h"" // NOLINT
#endif
// clang-format on
#include ""absl/types/optional.h""
#include ""ml_metadata/metadata_store/list_operation_util.h""
#include ""ml_metadata/proto/metadata_source.pb.h""
#include ""ml_metadata/proto/metadata_store.pb.h""
#include ""ml_metadata/util/struct_utils.h""
#include ""tensorflow/core/lib/core/errors.h""
#include ""tensorflow/core/lib/core/status.h""

namespace ml_metadata {
namespace {

TypeKind ResolveTypeKind(const ArtifactType* const type) {
  return TypeKind::ARTIFACT_TYPE;
}

TypeKind ResolveTypeKind(const ExecutionType* const type) {
  return TypeKind::EXECUTION_TYPE;
}

TypeKind ResolveTypeKind(const ContextType* const type) {
  return TypeKind::CONTEXT_TYPE;
}

// Populates 'node' properties from the rows in 'record'. The assumption is that
// properties are encoded using the convention in
// QueryExecutor::Get{X}PropertyBy{X}Id() where X in {Artifact, Execution,
// Context}.
template <typename Node>
tensorflow::Status PopulateNodeProperties(const RecordSet::Record& record,
                                          Node& node) {
  // Populate the property of the node.
  const std::string& property_name = record.values(1);
  bool is_custom_property;
  CHECK(absl::SimpleAtob(record.values(2), &is_custom_property));
  auto& property_value =
      (is_custom_property ? (*node.mutable_custom_properties())[property_name]
                          : (*node.mutable_properties())[property_name]);
  if (record.values(3) != kMetadataSourceNull) {
    int64 int_value;
    CHECK(absl::SimpleAtoi(record.values(3), &int_value));
    property_value.set_int_value(int_value);
  } else if (record.values(4) != kMetadataSourceNull) {
    double double_value;
    CHECK(absl::SimpleAtod(record.values(4), &double_value));
    property_value.set_double_value(double_value);
  } else {
    const std::string& string_value = record.values(5);
    if (IsStructSerializedString(string_value)) {
      TF_RETURN_IF_ERROR(
          StringToStruct(string_value, *property_value.mutable_struct_value()));
    } else {
      property_value.set_string_value(string_value);
    }
  }

  return tensorflow::Status::OK();
}

// Converts a record set that contains an id column at position per record to a
// vector.
std::vector<int64> ConvertToIds(const RecordSet& record_set, int position = 0) {
  std::vector<int64> result;
  result.reserve(record_set.records().size());
  for (const RecordSet::Record& record : record_set.records()) {
    int64 id;
    CHECK(absl::SimpleAtoi(record.values(position), &id));
    result.push_back(id);
  }
  return result;
}

// Extracts a vector of type ids from the parent_type triplets.
std::vector<int64> ParentTypesToParentTypeIds(const RecordSet& record_set) {
  return ConvertToIds(record_set, /*position=*/1);
}

// Extracts a vector of context ids from attribution triplets.
std::vector<int64> AttributionsToContextIds(const RecordSet& record_set) {
  return ConvertToIds(record_set, /*position=*/1);
}

// Extracts a vector of context ids from attribution triplets.
std::vector<int64> AttributionsToArtifactIds(const RecordSet& record_set) {
  return ConvertToIds(record_set, /*position=*/2);
}

// Extracts a vector of context ids from association triplets.
std::vector<int64> AssociationsToContextIds(const RecordSet& record_set) {
  return ConvertToIds(record_set, /*position=*/1);
}

// Extracts a vector of execution ids from association triplets.
std::vector<int64> AssociationsToExecutionIds(const RecordSet& record_set) {
  return ConvertToIds(record_set, /*position=*/2);
}

// Extracts a vector of parent context ids from parent context triplets.
// If is_parent is true, then parent_context_ids are returned.
// If is_parent is false, then context_ids for children are returned.
std::vector<int64> ParentContextsToContextIds(const RecordSet& record_set,
                                              bool is_parent) {
  const int position = is_parent ? 1 : 0;
  return ConvertToIds(record_set, position);
}

// Parses and converts a string value to a specific field in a message.
// If the given string `value` is NULL (encoded as kMetadataSourceNull), then
// leave the field unset.
// The field should be a scalar field. The field type must be one of {string,
// int64, bool, enum, message}.
tensorflow::Status ParseValueToField(
    const google::protobuf::FieldDescriptor* field_descriptor,
    const absl::string_view value, google::protobuf::Message* message) {
  if (value == kMetadataSourceNull) {
    return tensorflow::Status::OK();
  }
  const google::protobuf::Reflection* reflection = message->GetReflection();
  switch (field_descriptor->cpp_type()) {
    case google::protobuf::FieldDescriptor::CppType::CPPTYPE_STRING: {
      if (field_descriptor->is_repeated())
        reflection->AddString(message, field_descriptor, std::string(value));
      else
        reflection->SetString(message, field_descriptor, std::string(value));
      break;
    }
    case google::protobuf::FieldDescriptor::CppType::CPPTYPE_INT64: {
      int64 int64_value;
      CHECK(absl::SimpleAtoi(value, &int64_value));
      if (field_descriptor->is_repeated())
        reflection->AddInt64(message, field_descriptor, int64_value);
      else
        reflection->SetInt64(message, field_descriptor, int64_value);
      break;
    }
    case google::protobuf::FieldDescriptor::CppType::CPPTYPE_BOOL: {
      bool bool_value;
      CHECK(absl::SimpleAtob(value, &bool_value));
      if (field_descriptor->is_repeated())
        reflection->AddBool(message, field_descriptor, bool_value);
      else
        reflection->SetBool(message, field_descriptor, bool_value);
      break;
    }
    case google::protobuf::FieldDescriptor::CppType::CPPTYPE_ENUM: {
      int enum_value;
      CHECK(absl::SimpleAtoi(value, &enum_value));
      if (field_descriptor->is_repeated())
        reflection->AddEnumValue(message, field_descriptor, enum_value);
      else
        reflection->SetEnumValue(message, field_descriptor, enum_value);
      break;
    }
    case google::protobuf::FieldDescriptor::CppType::CPPTYPE_MESSAGE: {
      CHECK(!field_descriptor->is_repeated())
          << ""Cannot handle a repeated message"";
      if (!value.empty()) {
        ::google::protobuf::Message* sub_message =
            reflection->MutableMessage(message, field_descriptor);
        if (!::google::protobuf::util::JsonStringToMessage(
                 std::string(value.begin(), value.size()), sub_message)
                 .ok()) {
          return tensorflow::errors::Internal(
              ::absl::StrCat(""Failed to parse proto: "", value));
        }
      }
      break;
    }
    default: {
      return tensorflow::errors::Internal(absl::StrCat(
          ""Unsupported field type: "", field_descriptor->cpp_type()));
    }
  }
  return tensorflow::Status::OK();
}

// Converts a RecordSet in the query result to a MessageType. In the record at
// the `record_index`, its value of each column is assigned to a message field
// with the same field name as the column name.
template <typename MessageType>
tensorflow::Status ParseRecordSetToMessage(const RecordSet& record_set,
                                           MessageType* message,
                                           int record_index = 0) {
  CHECK_LT(record_index, record_set.records_size());
  const google::protobuf::Descriptor* descriptor = message->descriptor();
  for (int i = 0; i < record_set.column_names_size(); i++) {
    const std::string& column_name = record_set.column_names(i);
    const google::protobuf::FieldDescriptor* field_descriptor =
        descriptor->FindFieldByName(column_name);
    if (field_descriptor != nullptr) {
      const std::string& value = record_set.records(record_index).values(i);
      TF_RETURN_IF_ERROR(ParseValueToField(field_descriptor, value, message));
    }
  }
  return tensorflow::Status::OK();
}

// Converts a RecordSet in the query result to a MessageType array.
template <typename MessageType>
tensorflow::Status ParseRecordSetToMessageArray(
    const RecordSet& record_set, std::vector<MessageType>* messages) {
  for (int i = 0; i < record_set.records_size(); i++) {
    messages->push_back(MessageType());
    TF_RETURN_IF_ERROR(
        ParseRecordSetToMessage(record_set, &messages->back(), i));
  }
  return tensorflow::Status::OK();
}

// Converts a RecordSet containing key-value pairs to a proto Map.
// The field_name is the map field in the MessageType. The method fills the
// message's map field with field_name using the rows in the given record_set.
template <typename MessageType>
tensorflow::Status ParseRecordSetToMapField(const RecordSet& record_set,
                                            const std::string& field_name,
                                            MessageType* message) {
  const google::protobuf::Descriptor* descriptor = message->descriptor();
  const google::protobuf::Reflection* reflection = message->GetReflection();
  const google::protobuf::FieldDescriptor* map_field_descriptor =
      descriptor->FindFieldByName(field_name);
  if (map_field_descriptor == nullptr || !map_field_descriptor->is_map()) {
    return tensorflow::errors::Internal(
        absl::StrCat(""Cannot find map field with field name: "", field_name));
  }

  const google::protobuf::FieldDescriptor* key_descriptor =
      map_field_descriptor->message_type()->FindFieldByName(""key"");
  const google::protobuf::FieldDescriptor* value_descriptor =
      map_field_descriptor->message_type()->FindFieldByName(""value"");

  for (const RecordSet::Record& record : record_set.records()) {
    google::protobuf::Message* map_field_message =
        reflection->AddMessage(message, map_field_descriptor);
    const std::string& key = record.values(0);
    const std::string& value = record.values(1);
    TF_RETURN_IF_ERROR(
        ParseValueToField(key_descriptor, key, map_field_message));
    TF_RETURN_IF_ERROR(
        ParseValueToField(value_descriptor, value, map_field_message));
  }

  return tensorflow::Status::OK();
}

// Validates properties in a `Node` with the properties defined in a `Type`.
// `Node` is one of {`Artifact`, `Execution`, `Context`}. `Type` is one of
// {`ArtifactType`, `ExecutionType`, `ContextType`}.
// Returns INVALID_ARGUMENT error, if there is unknown or mismatched property
// w.r.t. its definition.
template <typename Node, typename Type>
tensorflow::Status ValidatePropertiesWithType(const Node& node,
                                              const Type& type) {
  const google::protobuf::Map<std::string, PropertyType>& type_properties =
      type.properties();
  for (const auto& p : node.properties()) {
    const std::string& property_name = p.first;
    const Value& property_value = p.second;
    // Note that this is a google::protobuf::Map, not a std::map.
    if (type_properties.find(property_name) == type_properties.end())
      return tensorflow::errors::InvalidArgument(
          absl::StrCat(""Found unknown property: "", property_name));
    bool is_type_match = false;
    switch (type_properties.at(property_name)) {
      case PropertyType::INT: {
        is_type_match = property_value.has_int_value();
        break;
      }
      case PropertyType::DOUBLE: {
        is_type_match = property_value.has_double_value();
        break;
      }
      case PropertyType::STRING: {
        is_type_match = property_value.has_string_value();
        break;
      }
      case PropertyType::STRUCT: {
        is_type_match = property_value.has_struct_value();
        break;
      }
      default: {
        return tensorflow::errors::Internal(absl::StrCat(
            ""Unknown registered property type: "", type.DebugString()));
      }
    }
    if (!is_type_match)
      return tensorflow::errors::InvalidArgument(
          absl::StrCat(""Found unmatched property type: "", property_name));
  }
  return tensorflow::Status::OK();
}

// Casts lower level db error messages for violating primary key constraint or
// unique constraint. Returns true when the status error message indicates such
// unique constraint is violated.
bool IsUniqueConstraintViolated(const tensorflow::Status status) {
  return tensorflow::errors::IsInternal(status) &&
         (absl::StrContains(status.error_message(), ""Duplicate"") ||
          absl::StrContains(status.error_message(), ""UNIQUE""));
}

// A util to handle `version` in ArtifactType/ExecutionType/ContextType protos.
template <typename T>
absl::optional<std::string> GetTypeVersion(const T& type_message) {
  return type_message.has_version() && !type_message.version().empty()
             ? absl::make_optional(type_message.version())
             : absl::nullopt;
}

}  // namespace

// Creates an Artifact (without properties).
tensorflow::Status RDBMSMetadataAccessObject::CreateBasicNode(
    const Artifact& artifact, int64* node_id) {
  const absl::Time now = absl::Now();
  return executor_->InsertArtifact(
      artifact.type_id(), artifact.uri(),
      artifact.has_state() ? absl::make_optional(artifact.state())
                           : absl::nullopt,
      artifact.has_name() ? absl::make_optional(artifact.name())
                          : absl::nullopt,
      now, now, node_id);
}

// Creates an Execution (without properties).
tensorflow::Status RDBMSMetadataAccessObject::CreateBasicNode(
    const Execution& execution, int64* node_id) {
  const absl::Time now = absl::Now();
  return executor_->InsertExecution(
      execution.type_id(),
      execution.has_last_known_state()
          ? absl::make_optional(execution.last_known_state())
          : absl::nullopt,
      execution.has_name() ? absl::make_optional(execution.name())
                           : absl::nullopt,
      now, now, node_id);
}

// Creates a Context (without properties).
tensorflow::Status RDBMSMetadataAccessObject::CreateBasicNode(
    const Context& context, int64* node_id) {
  const absl::Time now = absl::Now();
  if (!context.has_name() || context.name().empty()) {
    return tensorflow::errors::InvalidArgument(
        ""Context name should not be empty"");
  }
  return executor_->InsertContext(context.type_id(), context.name(), now, now,
                                  node_id);
}

template <>
tensorflow::Status RDBMSMetadataAccessObject::RetrieveNodesById(
    const absl::Span<const int64> ids, RecordSet* header, RecordSet* properties,
    Context* tag) {
  TF_RETURN_IF_ERROR(executor_->SelectContextsByID(ids, header));
  if (!header->records().empty()) {
    TF_RETURN_IF_ERROR(
        executor_->SelectContextPropertyByContextID(ids, properties));
  }
  return tensorflow::Status::OK();
}

template <>
tensorflow::Status RDBMSMetadataAccessObject::RetrieveNodesById(
    const absl::Span<const int64> ids, RecordSet* header, RecordSet* properties,
    Artifact* tag) {
  TF_RETURN_IF_ERROR(executor_->SelectArtifactsByID(ids, header));
  if (!header->records().empty()) {
    TF_RETURN_IF_ERROR(
        executor_->SelectArtifactPropertyByArtifactID(ids, properties));
  }
  return tensorflow::Status::OK();
}

template <>
tensorflow::Status RDBMSMetadataAccessObject::RetrieveNodesById(
    const absl::Span<const int64> ids, RecordSet* header, RecordSet* properties,
    Execution* tag) {
  TF_RETURN_IF_ERROR(executor_->SelectExecutionsByID(ids, header));
  if (!header->records().empty()) {
    TF_RETURN_IF_ERROR(
        executor_->SelectExecutionPropertyByExecutionID(ids, properties));
  }
  return tensorflow::Status::OK();
}

// Update an Artifact's type_id, URI and last_update_time.
tensorflow::Status RDBMSMetadataAccessObject::RunNodeUpdate(
    const Artifact& artifact) {
  return executor_->UpdateArtifactDirect(
      artifact.id(), artifact.type_id(), artifact.uri(),
      artifact.has_state() ? absl::make_optional(artifact.state())
                           : absl::nullopt,
      absl::Now());
}

// Update an Execution's type_id and last_update_time.
tensorflow::Status RDBMSMetadataAccessObject::RunNodeUpdate(
    const Execution& execution) {
  return executor_->UpdateExecutionDirect(
      execution.id(), execution.type_id(),
      execution.has_last_known_state()
          ? absl::make_optional(execution.last_known_state())
          : absl::nullopt,
      absl::Now());
}

// Update a Context's type id and name.
tensorflow::Status RDBMSMetadataAccessObject::RunNodeUpdate(
    const Context& context) {
  if (!context.has_name() || context.name().empty()) {
    return tensorflow::errors::InvalidArgument(
        ""Context name should not be empty"");
  }
  return executor_->UpdateContextDirect(context.id(), context.type_id(),
                                        context.name(), absl::Now());
}

// Runs a property insertion query for a NodeType.
template <typename NodeType>
tensorflow::Status RDBMSMetadataAccessObject::InsertProperty(
    const int64 node_id, const absl::string_view name,
    const bool is_custom_property, const Value& value) {
  NodeType node;
  const TypeKind type_kind = ResolveTypeKind(&node);
  MetadataSourceQueryConfig::TemplateQuery insert_property;
  switch (type_kind) {
    case TypeKind::ARTIFACT_TYPE:
      return executor_->InsertArtifactProperty(node_id, name,
                                               is_custom_property, value);
    case TypeKind::EXECUTION_TYPE:
      return executor_->InsertExecutionProperty(node_id, name,
                                                is_custom_property, value);

    case TypeKind::CONTEXT_TYPE:
      return executor_->InsertContextProperty(node_id, name, is_custom_property,
                                              value);
    default:
      return tensorflow::errors::Internal(
          absl::StrCat(""Unsupported TypeKind: "", type_kind));
  }
}

// Generates a property update query for a NodeType.
template <typename NodeType>
tensorflow::Status RDBMSMetadataAccessObject::UpdateProperty(
    const int64 node_id, const absl::string_view name, const Value& value) {
  NodeType node;
  const TypeKind type_kind = ResolveTypeKind(&node);
  MetadataSourceQueryConfig::TemplateQuery update_property;
  switch (type_kind) {
    case TypeKind::ARTIFACT_TYPE:
      return executor_->UpdateArtifactProperty(node_id, name, value);
    case TypeKind::EXECUTION_TYPE:
      return executor_->UpdateExecutionProperty(node_id, name, value);
    case TypeKind::CONTEXT_TYPE:
      return executor_->UpdateContextProperty(node_id, name, value);
    default:
      return tensorflow::errors::Internal(
          absl::StrCat(""Unsupported TypeKind: "", type_kind));
  }
}

// Generates a property deletion query for a NodeType.
template <typename NodeType>
tensorflow::Status RDBMSMetadataAccessObject::DeleteProperty(
    const int64 node_id, const absl::string_view name) {
  NodeType type;
  const TypeKind type_kind = ResolveTypeKind(&type);
  switch (type_kind) {
    case TypeKind::ARTIFACT_TYPE:
      return executor_->DeleteArtifactProperty(node_id, name);
    case TypeKind::EXECUTION_TYPE:
      return executor_->DeleteExecutionProperty(node_id, name);
    case TypeKind::CONTEXT_TYPE:
      return executor_->DeleteContextProperty(node_id, name);
    default:
      return tensorflow::errors::Internal(""Unsupported TypeKind."");
  }
}

// Generates a list of queries for the `curr_properties` (C) based on the given
// `prev_properties` (P). A property definition is a 2-tuple (name, value_type).
// a) any property in the intersection of C and P, a update query is generated.
// b) any property in C \\ P, insert query is generated.
// c) any property in P \\ C, delete query is generated.
// The queries are composed from corresponding template queries with the given
// `NodeType` (which is one of {`ArtifactType`, `ExecutionType`, `ContextType`}
// and the `is_custom_property` (which indicates the space of the given
// properties.
// Returns `output_num_changed_properties` which equals to the number of
// properties are changed (deleted, updated or inserted).
template <typename NodeType>
tensorflow::Status RDBMSMetadataAccessObject::ModifyProperties(
    const google::protobuf::Map<std::string, Value>& curr_properties,
    const google::protobuf::Map<std::string, Value>& prev_properties, const int64 node_id,
    const bool is_custom_property, int& output_num_changed_properties) {
  output_num_changed_properties = 0;
  // generates delete clauses for properties in P \\ C
  for (const auto& p : prev_properties) {
    const std::string& name = p.first;
    const Value& value = p.second;
    // check the 2-tuple (name, value_type) in prev_properties
    if (curr_properties.find(name) != curr_properties.end() &&
        curr_properties.at(name).value_case() == value.value_case())
      continue;

    TF_RETURN_IF_ERROR(DeleteProperty<NodeType>(node_id, name));
    output_num_changed_properties++;
  }

  for (const auto& p : curr_properties) {
    const std::string& name = p.first;
    const Value& value = p.second;
    const auto prev_value_it = prev_properties.find(name);
    if (prev_value_it != prev_properties.end() &&
        prev_value_it->second.value_case() == p.second.value_case()) {
      if (!google::protobuf::util::MessageDifferencer::Equals(prev_value_it->second,
                                                    value)) {
        // generates update clauses for properties in the intersection P & C
        TF_RETURN_IF_ERROR(UpdateProperty<NodeType>(node_id, name, value));
        output_num_changed_properties++;
      }
    } else {
      // generate insert clauses for properties in C \\ P
      TF_RETURN_IF_ERROR(
          InsertProperty<NodeType>(node_id, name, is_custom_property, value));
      output_num_changed_properties++;
    }
  }
  return tensorflow::Status::OK();
}

// Creates a query to insert an artifact type.
tensorflow::Status RDBMSMetadataAccessObject::InsertTypeID(
    const ArtifactType& type, int64* type_id) {
  return executor_->InsertArtifactType(
      type.name(), GetTypeVersion(type),
      type.has_description() ? absl::make_optional(type.description())
                             : absl::nullopt,
      type_id);
}

// Creates a query to insert an execution type.
tensorflow::Status RDBMSMetadataAccessObject::InsertTypeID(
    const ExecutionType& type, int64* type_id) {
  return executor_->InsertExecutionType(
      type.name(), GetTypeVersion(type),
      type.has_description() ? absl::make_optional(type.description())
                             : absl::nullopt,
      type.has_input_type() ? &type.input_type() : nullptr,
      type.has_output_type() ? &type.output_type() : nullptr, type_id);
}

// Creates a query to insert a context type.
tensorflow::Status RDBMSMetadataAccessObject::InsertTypeID(
    const ContextType& type, int64* type_id) {
  return executor_->InsertContextType(
      type.name(), GetTypeVersion(type),
      type.has_description() ? absl::make_optional(type.description())
                             : absl::nullopt,
      type_id);
}

// Creates a `Type` where acceptable ones are in {ArtifactType, ExecutionType,
// ContextType}.
// Returns INVALID_ARGUMENT error, if name field is not given.
// Returns INVALID_ARGUMENT error, if any property type is unknown.
// Returns detailed INTERNAL error, if query execution fails.
template <typename Type>
tensorflow::Status RDBMSMetadataAccessObject::CreateTypeImpl(const Type& type,
                                                             int64* type_id) {
  const std::string& type_name = type.name();
  const google::protobuf::Map<std::string, PropertyType>& type_properties =
      type.properties();

  // validate the given type
  if (type_name.empty())
    return tensorflow::errors::InvalidArgument(""No type name is specified."");
  if (type_properties.empty())
    LOG(WARNING) << ""No property is defined for the Type"";

  // insert a type and get its given id
  TF_RETURN_IF_ERROR(InsertTypeID(type, type_id));

  // insert type properties and commit
  for (const auto& property : type_properties) {
    const std::string& property_name = property.first;
    const PropertyType property_type = property.second;
    if (property_type == PropertyType::UNKNOWN) {
      LOG(ERROR) << ""Property "" << property_name << ""'s value type is UNKNOWN."";
      return tensorflow::errors::InvalidArgument(
          absl::StrCat(""Property "", property_name, "" is UNKNOWN.""));
    }
    TF_RETURN_IF_ERROR(
        executor_->InsertTypeProperty(*type_id, property_name, property_type));
  }
  return tensorflow::Status::OK();
}

// Generates a query to find all type instances.
tensorflow::Status RDBMSMetadataAccessObject::GenerateFindAllTypeInstancesQuery(
    const TypeKind type_kind, RecordSet* record_set) {
  return executor_->SelectAllTypes(type_kind, record_set);
}

// FindType takes a result of a query for types, and populates additional
// information such as properties, and returns it in `types`.
template <typename MessageType>
tensorflow::Status RDBMSMetadataAccessObject::FindTypesFromRecordSet(
    const RecordSet& type_record_set, std::vector<MessageType>* types) {
  // Query type with the given condition
  const int num_records = type_record_set.records_size();
  types->resize(num_records);
  for (int i = 0; i < num_records; ++i) {
    TF_RETURN_IF_ERROR(
        ParseRecordSetToMessage(type_record_set, &types->at(i), i));

    RecordSet property_record_set;
    TF_RETURN_IF_ERROR(executor_->SelectPropertyByTypeID(types->at(i).id(),
                                                         &property_record_set));

    TF_RETURN_IF_ERROR(ParseRecordSetToMapField(property_record_set,
                                                ""properties"", &types->at(i)));
  }

  return tensorflow::Status::OK();
}

template <typename MessageType>
tensorflow::Status RDBMSMetadataAccessObject::FindTypeImpl(int64 type_id,
                                                           MessageType* type) {
  const TypeKind type_kind = ResolveTypeKind(type);
  RecordSet record_set;
  TF_RETURN_IF_ERROR(
      executor_->SelectTypeByID(type_id, type_kind, &record_set));
  std::vector<MessageType> types;
  TF_RETURN_IF_ERROR(FindTypesFromRecordSet(record_set, &types));
  if (types.empty()) {
    return tensorflow::errors::NotFound(""No type found for query, type_id: "",
                                        type_id);
  }
  *type = std::move(types[0]);
  return tensorflow::Status::OK();
}

template <typename MessageType>
tensorflow::Status RDBMSMetadataAccessObject::FindTypeImpl(
    absl::string_view name, absl::optional<absl::string_view> version,
    MessageType* type) {
  const TypeKind type_kind = ResolveTypeKind(type);
  RecordSet record_set;
  TF_RETURN_IF_ERROR(executor_->SelectTypeByNameAndVersion(
      name, version, type_kind, &record_set));
  std::vector<MessageType> types;
  TF_RETURN_IF_ERROR(FindTypesFromRecordSet(record_set, &types));
  if (types.empty()) {
    return tensorflow::errors::NotFound(""No type found for query, name: `"",
                                        name, ""`, version: `"",
                                        version ? *version : ""nullopt"", ""`"");
  }
  *type = std::move(types[0]);
  return tensorflow::Status::OK();
}

// Finds all type instances of the type `MessageType`.
// Returns detailed INTERNAL error, if query execution fails.
template <typename MessageType>
tensorflow::Status RDBMSMetadataAccessObject::FindAllTypeInstancesImpl(
    std::vector<MessageType>* types) {
  MessageType type;
  const TypeKind type_kind = ResolveTypeKind(&type);
  RecordSet record_set;
  TF_RETURN_IF_ERROR(GenerateFindAllTypeInstancesQuery(type_kind, &record_set));

  return FindTypesFromRecordSet(record_set, types);
}

// Updates an existing type. A type is one of {ArtifactType, ExecutionType,
// ContextType}
// Returns INVALID_ARGUMENT error, if name field is not given.
// Returns INVALID_ARGUMENT error, if id field is given and is different.
// Returns INVALID_ARGUMENT error, if any property type is unknown.
// Returns ALREADY_EXISTS error, if any property type is different.
// Returns detailed INTERNAL error, if query execution fails.
template <typename Type>
tensorflow::Status RDBMSMetadataAccessObject::UpdateTypeImpl(const Type& type) {
  if (!type.has_name()) {
    return tensorflow::errors::InvalidArgument(""No type name is specified."");
  }
  // find the current stored type and validate the id.
  Type stored_type;
  TF_RETURN_IF_ERROR(FindTypeByNameAndVersion(type.name(), GetTypeVersion(type),
                                              &stored_type));
  if (type.has_id() && type.id() != stored_type.id()) {
    return tensorflow::errors::InvalidArgument(
        ""Given type id is different from the existing type: "",
        stored_type.DebugString());
  }
  // updates the list of type properties
  const google::protobuf::Map<std::string, PropertyType>& stored_properties =
      stored_type.properties();
  for (const auto& p : type.properties()) {
    const std::string& property_name = p.first;
    const PropertyType property_type = p.second;
    if (property_type == PropertyType::UNKNOWN) {
      return tensorflow::errors::InvalidArgument(
          ""Property:"", property_name, "" type should not be UNKNOWN."");
    }
    if (stored_properties.find(property_name) != stored_properties.end()) {
      // for stored properties, type should not be changed.
      if (stored_properties.at(property_name) != property_type) {
        return tensorflow::errors::AlreadyExists(
            ""Property:"", property_name,
            "" type is different from the existing type: "",
            stored_type.DebugString());
      }
      continue;
    }
    TF_RETURN_IF_ERROR(executor_->InsertTypeProperty(
        stored_type.id(), property_name, property_type));
  }
  return tensorflow::Status::OK();
}

template <typename Type>
tensorflow::Status RDBMSMetadataAccessObject::CreateParentTypeImpl(
    const int64 type_id, const int64 parent_type_id) {
  // Check whether there is a cyclic dependency if we insert the tuple:
  // (type_id, parent_type_id). We do a DFS traversal from `parent_type_id` as
  // the root node and it introduces a cycle if any ancestors is `type_id`. It
  // assumes that existing parent types inheritance are acyclic.
  std::vector<int64> ancestor_ids = {parent_type_id};
  absl::flat_hash_set<int64> visited_ancestors_ids;
  while (!ancestor_ids.empty()) {
    const int64 ancestor_id = ancestor_ids.back();
    if (ancestor_id == type_id) {
      return tensorflow::errors::InvalidArgument(
          ""There is a cycle detected of the given parent type."");
    }
    ancestor_ids.pop_back();
    if (visited_ancestors_ids.contains(ancestor_id)) {
      continue;
    }
    visited_ancestors_ids.insert(ancestor_id);
    RecordSet record_set;
    TF_RETURN_IF_ERROR(
        executor_->SelectParentTypesByTypeID(ancestor_id, &record_set));
    for (const int64 parent_id : ParentTypesToParentTypeIds(record_set)) {
      ancestor_ids.push_back(parent_id);
    }
  }
  const tensorflow::Status status =
      executor_->InsertParentType(type_id, parent_type_id);
  if (IsUniqueConstraintViolated(status)) {
    return tensorflow::errors::AlreadyExists(""The ParentType already exists."");
  }
  return status;
}

template <typename Type>
tensorflow::Status RDBMSMetadataAccessObject::FindParentTypesByTypeIdImpl(
    int64 type_id, std::vector<Type>& output_parent_types) {
  // check the there's a Type instance with the given type_id
  Type type;
  TF_RETURN_IF_ERROR(FindTypeImpl(type_id, &type));
  RecordSet record_set;
  TF_RETURN_IF_ERROR(
      executor_->SelectParentTypesByTypeID(type_id, &record_set));
  const std::vector<int64> ids = ParentTypesToParentTypeIds(record_set);
  const int output_size = output_parent_types.size();
  output_parent_types.resize(output_size + ids.size());
  // TODO(b/169075639) Use a single query to retrieve a list of types.
  for (int i = output_size; i < output_size + ids.size(); i++) {
    TF_RETURN_IF_ERROR(FindTypeImpl(ids[i], &output_parent_types.at(i)));
  }
  return tensorflow::Status::OK();
}

// Creates an `Node`, which is one of {`Artifact`, `Execution`, `Context`},
// then returns the assigned node id. The node's id field is ignored. The node
// should have a `NodeType`, which is one of {`ArtifactType`, `ExecutionType`,
// `ContextType`}.
// Returns INVALID_ARGUMENT error, if the node does not align with its type.
// Returns detailed INTERNAL error, if query execution fails.
template <typename Node, typename NodeType>
tensorflow::Status RDBMSMetadataAccessObject::CreateNodeImpl(const Node& node,
                                                             int64* node_id) {
  // clear node id
  *node_id = 0;
  // validate type
  if (!node.has_type_id())
    return tensorflow::errors::InvalidArgument(""Type id is missing."");
  const int64 type_id = node.type_id();
  NodeType node_type;
  TF_RETURN_WITH_CONTEXT_IF_ERROR(FindTypeImpl(type_id, &node_type),
                                  ""Cannot find type for "",
                                  node.ShortDebugString());

  // validate properties
  TF_RETURN_WITH_CONTEXT_IF_ERROR(ValidatePropertiesWithType(node, node_type),
                                  ""Cannot validate properties of "",
                                  node.ShortDebugString());

  // insert a node and get the assigned id
  TF_RETURN_WITH_CONTEXT_IF_ERROR(CreateBasicNode(node, node_id),
                                  ""Cannot create node for "",
                                  node.ShortDebugString());

  // insert properties
  const google::protobuf::Map<std::string, Value> prev_properties;
  int num_changed_properties = 0;
  TF_RETURN_IF_ERROR(ModifyProperties<NodeType>(
      node.properties(), prev_properties, *node_id,
      /*is_custom_property=*/false, num_changed_properties));
  int num_changed_custom_properties = 0;
  TF_RETURN_IF_ERROR(ModifyProperties<NodeType>(
      node.custom_properties(), prev_properties, *node_id,
      /*is_custom_property=*/true, num_changed_custom_properties));
  return tensorflow::Status::OK();
}

template <typename Node>
tensorflow::Status RDBMSMetadataAccessObject::FindNodesImpl(
    const absl::Span<const int64> node_ids, const bool skipped_ids_ok,
    std::vector<Node>& nodes) {
  if (node_ids.empty()) {
    return tensorflow::errors::InvalidArgument(""ids cannot be empty"");
  }

  if (!nodes.empty()) {
    return tensorflow::errors::InvalidArgument(""nodes parameter is not empty"");
  }

  RecordSet node_record_set;
  RecordSet properties_record_set;

  TF_RETURN_IF_ERROR(RetrieveNodesById<Node>(node_ids, &node_record_set,
                                             &properties_record_set));

  TF_RETURN_IF_ERROR(ParseRecordSetToMessageArray(node_record_set, &nodes));

  // if there are properties associated with the nodes, parse the returned
  // values.
  if (!properties_record_set.records().empty()) {
    // First we build a hash map from node ids to Node messages, to
    // facilitate lookups.
    absl::flat_hash_map<int64, typename std::vector<Node>::iterator> node_by_id;
    for (auto i = nodes.begin(); i != nodes.end(); ++i) {
      node_by_id.insert({i->id(), i});
    }

    CHECK_EQ(properties_record_set.column_names_size(), 6);
    for (const RecordSet::Record& record : properties_record_set.records()) {
      // Match the record against a node in the hash map.
      int64 node_id;
      CHECK(absl::SimpleAtoi(record.values(0), &node_id));
      auto iter = node_by_id.find(node_id);
      CHECK(iter != node_by_id.end());
      Node& node = *iter->second;

      TF_RETURN_IF_ERROR(PopulateNodeProperties(record, node));
    }
  }

  if (node_ids.size() != nodes.size()) {
    std::vector<int64> found_ids;
    absl::c_transform(nodes, std::back_inserter(found_ids),
                      [](const Node& node) { return node.id(); });

    const std::string message = absl::StrCat(
        ""Results missing for ids: {"", absl::StrJoin(node_ids, "",""),
        ""}. Found results for {"", absl::StrJoin(found_ids, "",""), ""}"");

    if (!skipped_ids_ok) {
      return tensorflow::errors::Internal(message);
    } else {
      return tensorflow::errors::NotFound(message);
    }
  }
  return tensorflow::Status::OK();
}

template <typename Node>
tensorflow::Status RDBMSMetadataAccessObject::FindNodeImpl(const int64 node_id,
                                                           Node* node) {
  std::vector<Node> nodes;
  TF_RETURN_IF_ERROR(FindNodesImpl({node_id}, /*skipped_ids_ok=*/true, nodes));
  *node = nodes.at(0);

  return tensorflow::Status::OK();
}

// Updates a `Node` which is one of {`Artifact`, `Execution`, `Context`}.
// Returns INVALID_ARGUMENT error, if the node cannot be found
// Returns INVALID_ARGUMENT error, if the node does not match with its type
// Returns detailed INTERNAL error, if query execution fails.
template <typename Node, typename NodeType>
tensorflow::Status RDBMSMetadataAccessObject::UpdateNodeImpl(const Node& node) {
  // validate node
  if (!node.has_id())
    return tensorflow::errors::InvalidArgument(""No id is given."");

  Node stored_node;
  tensorflow::Status status = FindNodeImpl(node.id(), &stored_node);
  if (tensorflow::errors::IsNotFound(status)) {
    return tensorflow::errors::InvalidArgument(
        absl::StrCat(""Cannot find the given id "", node.id()));
  }
  if (!status.ok()) return status;
  if (node.has_type_id() && node.type_id() != stored_node.type_id()) {
    return tensorflow::errors::InvalidArgument(absl::StrCat(
        ""Given type_id "", node.type_id(),
        "" is different from the one known before: "", stored_node.type_id()));
  }
  const int64 type_id = stored_node.type_id();

  NodeType stored_type;
  TF_RETURN_IF_ERROR(FindTypeImpl(type_id, &stored_type));
  TF_RETURN_IF_ERROR(ValidatePropertiesWithType(node, stored_type));

  // Update, insert, delete properties if changed.
  int num_changed_properties = 0;
  TF_RETURN_IF_ERROR(ModifyProperties<NodeType>(
      node.properties(), stored_node.properties(), node.id(),
      /*is_custom_property=*/false, num_changed_properties));
  int num_changed_custom_properties = 0;
  TF_RETURN_IF_ERROR(ModifyProperties<NodeType>(
      node.custom_properties(), stored_node.custom_properties(), node.id(),
      /*is_custom_property=*/true, num_changed_custom_properties));
  // Update node if attributes are different or properties are updated, so that
  // the last_update_time_since_epoch is updated properly.
  google::protobuf::util::MessageDifferencer diff;
  diff.IgnoreField(Node::descriptor()->FindFieldByName(""properties""));
  diff.IgnoreField(Node::descriptor()->FindFieldByName(""custom_properties""));
  // create_time_since_epoch and last_update_time_since_epoch are output only
  // fields. Two nodes are treated as equal as long as other fields match.
  diff.IgnoreField(
      Node::descriptor()->FindFieldByName(""create_time_since_epoch""));
  diff.IgnoreField(
      Node::descriptor()->FindFieldByName(""last_update_time_since_epoch""));
  if (!diff.Compare(node, stored_node) ||
      num_changed_properties + num_changed_custom_properties > 0) {
    TF_RETURN_IF_ERROR(RunNodeUpdate(node));
  }
  return tensorflow::Status::OK();
}

// Takes a record set that has one record per event, parses them into Event
// objects, gets the paths for the events from the database using collected
// event ids, and assign paths to each corresponding event.
// Returns INVALID_ARGUMENT error, if the `events` is null.
tensorflow::Status RDBMSMetadataAccessObject::FindEventsFromRecordSet(
    const RecordSet& event_record_set, std::vector<Event>* events) {
  if (events == nullptr)
    return tensorflow::errors::InvalidArgument(""Given events is NULL."");

  events->reserve(event_record_set.records_size());
  TF_RETURN_IF_ERROR(ParseRecordSetToMessageArray(event_record_set, events));

  absl::flat_hash_map<int64, Event*> event_id_to_event_map;
  std::vector<int64> event_ids;
  event_ids.reserve(event_record_set.records_size());
  for (int i = 0; i < events->size(); ++i) {
    CHECK_LT(i, event_record_set.records_size());
    const RecordSet::Record& record = event_record_set.records()[i];
    int64 event_id;
    CHECK(absl::SimpleAtoi(record.values(0), &event_id));
    event_id_to_event_map[event_id] = &(*events)[i];
    event_ids.push_back(event_id);
  }

  RecordSet path_record_set;
  TF_RETURN_IF_ERROR(
      executor_->SelectEventPathByEventIDs(event_ids, &path_record_set));
  for (const RecordSet::Record& record : path_record_set.records()) {
    int64 event_id;
    CHECK(absl::SimpleAtoi(record.values(0), &event_id));
    auto iter = event_id_to_event_map.find(event_id);
    CHECK(iter != event_id_to_event_map.end());
    Event* event = iter->second;
    bool is_index_step;
    CHECK(absl::SimpleAtob(record.values(1), &is_index_step));
    if (is_index_step) {
      int64 step_index;
      CHECK(absl::SimpleAtoi(record.values(2), &step_index));
      event->mutable_path()->add_steps()->set_index(step_index);
    } else {
      event->mutable_path()->add_steps()->set_key(record.values(3));
    }
  }
  return tensorflow::Status::OK();
}

tensorflow::Status RDBMSMetadataAccessObject::CreateType(
    const ArtifactType& type, int64* type_id) {
  return CreateTypeImpl(type, type_id);
}

tensorflow::Status RDBMSMetadataAccessObject::CreateType(
    const ExecutionType& type, int64* type_id) {
  return CreateTypeImpl(type, type_id);
}

tensorflow::Status RDBMSMetadataAccessObject::CreateType(
    const ContextType& type, int64* type_id) {
  return CreateTypeImpl(type, type_id);
}

tensorflow::Status RDBMSMetadataAccessObject::FindTypeById(
    const int64 type_id, ArtifactType* artifact_type) {
  return FindTypeImpl(type_id, artifact_type);
}

tensorflow::Status RDBMSMetadataAccessObject::FindTypeById(
    const int64 type_id, ExecutionType* execution_type) {
  return FindTypeImpl(type_id, execution_type);
}

tensorflow::Status RDBMSMetadataAccessObject::FindTypes(
    std::vector<ArtifactType>* artifact_types) {
  return FindAllTypeInstancesImpl(artifact_types);
}

tensorflow::Status RDBMSMetadataAccessObject::FindTypeById(
    const int64 type_id, ContextType* context_type) {
  return FindTypeImpl(type_id, context_type);
}

tensorflow::Status RDBMSMetadataAccessObject::FindTypes(
    std::vector<ExecutionType>* execution_types) {
  return FindAllTypeInstancesImpl(execution_types);
}

tensorflow::Status RDBMSMetadataAccessObject::FindTypes(
    std::vector<ContextType>* context_types) {
  return FindAllTypeInstancesImpl(context_types);
}

tensorflow::Status RDBMSMetadataAccessObject::FindTypeByNameAndVersion(
    absl::string_view name, absl::optional<absl::string_view> version,
    ArtifactType* artifact_type) {
  return FindTypeImpl(name, version, artifact_type);
}

tensorflow::Status RDBMSMetadataAccessObject::FindTypeByNameAndVersion(
    absl::string_view name, absl::optional<absl::string_view> version,
    ExecutionType* execution_type) {
  return FindTypeImpl(name, version, execution_type);
}

tensorflow::Status RDBMSMetadataAccessObject::FindTypeByNameAndVersion(
    absl::string_view name, absl::optional<absl::string_view> version,
    ContextType* context_type) {
  return FindTypeImpl(name, version, context_type);
}

tensorflow::Status RDBMSMetadataAccessObject::UpdateType(
    const ArtifactType& type) {
  return UpdateTypeImpl(type);
}

tensorflow::Status RDBMSMetadataAccessObject::UpdateType(
    const ExecutionType& type) {
  return UpdateTypeImpl(type);
}

tensorflow::Status RDBMSMetadataAccessObject::UpdateType(
    const ContextType& type) {
  return UpdateTypeImpl(type);
}

tensorflow::Status RDBMSMetadataAccessObject::CreateParentTypeInheritanceLink(
    const ArtifactType& type, const ArtifactType& parent_type) {
  if (!type.has_id() || !parent_type.has_id()) {
    return tensorflow::errors::InvalidArgument(
        ""Missing id in the given types: "", type.DebugString(),
        parent_type.DebugString());
  }
  return CreateParentTypeImpl<ArtifactType>(type.id(), parent_type.id());
}

tensorflow::Status RDBMSMetadataAccessObject::CreateParentTypeInheritanceLink(
    const ExecutionType& type, const ExecutionType& parent_type) {
  if (!type.has_id() || !parent_type.has_id()) {
    return tensorflow::errors::InvalidArgument(
        ""Missing id in the given types: "", type.DebugString(),
        parent_type.DebugString());
  }
  return CreateParentTypeImpl<ExecutionType>(type.id(), parent_type.id());
}

tensorflow::Status RDBMSMetadataAccessObject::CreateParentTypeInheritanceLink(
    const ContextType& type, const ContextType& parent_type) {
  if (!type.has_id() || !parent_type.has_id()) {
    return tensorflow::errors::InvalidArgument(
        ""Missing id in the given types: "", type.DebugString(),
        parent_type.DebugString());
  }
  return CreateParentTypeImpl<ContextType>(type.id(), parent_type.id());
}

tensorflow::Status RDBMSMetadataAccessObject::FindParentTypesByTypeId(
    int64 type_id, std::vector<ArtifactType>& output_parent_types) {
  return FindParentTypesByTypeIdImpl(type_id, output_parent_types);
}

tensorflow::Status RDBMSMetadataAccessObject::FindParentTypesByTypeId(
    int64 type_id, std::vector<ExecutionType>& output_parent_types) {
  return FindParentTypesByTypeIdImpl(type_id, output_parent_types);
}

tensorflow::Status RDBMSMetadataAccessObject::FindParentTypesByTypeId(
    int64 type_id, std::vector<ContextType>& output_parent_types) {
  return FindParentTypesByTypeIdImpl(type_id, output_parent_types);
}

tensorflow::Status RDBMSMetadataAccessObject::CreateArtifact(
    const Artifact& artifact, int64* artifact_id) {
  const tensorflow::Status& status =
      CreateNodeImpl<Artifact, ArtifactType>(artifact, artifact_id);
  if (IsUniqueConstraintViolated(status)) {
    return tensorflow::errors::AlreadyExists(
        ""Given node already exists: "", artifact.DebugString(), status);
  }
  return status;
}

tensorflow::Status RDBMSMetadataAccessObject::CreateExecution(
    const Execution& execution, int64* execution_id) {
  const tensorflow::Status& status =
      CreateNodeImpl<Execution, ExecutionType>(execution, execution_id);
  if (IsUniqueConstraintViolated(status)) {
    return tensorflow::errors::AlreadyExists(
        ""Given node already exists: "", execution.DebugString(), status);
  }
  return status;
}

tensorflow::Status RDBMSMetadataAccessObject::CreateContext(
    const Context& context, int64* context_id) {
  const tensorflow::Status& status =
      CreateNodeImpl<Context, ContextType>(context, context_id);
  if (IsUniqueConstraintViolated(status)) {
    return tensorflow::errors::AlreadyExists(
        ""Given node already exists: "", context.DebugString(), status);
  }
  return status;
}

tensorflow::Status RDBMSMetadataAccessObject::FindArtifactsById(
    const absl::Span<const int64> artifact_ids,
    std::vector<Artifact>* artifacts) {
  if (artifact_ids.empty()) {
    return tensorflow::Status::OK();
  }
  return FindNodesImpl(artifact_ids, /*skipped_ids_ok=*/true, *artifacts);
}

tensorflow::Status RDBMSMetadataAccessObject::FindExecutionsById(
    const absl::Span<const int64> execution_ids,
    std::vector<Execution>* executions) {
  if (execution_ids.empty()) {
    return tensorflow::Status::OK();
  }

  return FindNodesImpl(execution_ids, /*skipped_ids_ok=*/true, *executions);
}

tensorflow::Status RDBMSMetadataAccessObject::FindContextsById(
    const absl::Span<const int64> context_ids, std::vector<Context>* contexts) {
  if (context_ids.empty()) {
    return tensorflow::Status::OK();
  }
  return FindNodesImpl(context_ids, /*skipped_ids_ok=*/true, *contexts);
}

tensorflow::Status RDBMSMetadataAccessObject::UpdateArtifact(
    const Artifact& artifact) {
  return UpdateNodeImpl<Artifact, ArtifactType>(artifact);
}

tensorflow::Status RDBMSMetadataAccessObject::UpdateExecution(
    const Execution& execution) {
  return UpdateNodeImpl<Execution, ExecutionType>(execution);
}

tensorflow::Status RDBMSMetadataAccessObject::UpdateContext(
    const Context& context) {
  return UpdateNodeImpl<Context, ContextType>(context);
}

tensorflow::Status RDBMSMetadataAccessObject::CreateEvent(const Event& event,
                                                          int64* event_id) {
  // validate the given event
  if (!event.has_artifact_id())
    return tensorflow::errors::InvalidArgument(""No artifact id is specified."");
  if (!event.has_execution_id())
    return tensorflow::errors::InvalidArgument(""No execution id is specified."");
  if (!event.has_type() || event.type() == Event::UNKNOWN)
    return tensorflow::errors::InvalidArgument(""No event type is specified."");
  RecordSet artifacts;
  TF_RETURN_IF_ERROR(
      executor_->SelectArtifactsByID({event.artifact_id()}, &artifacts));
  RecordSet executions;
  TF_RETURN_IF_ERROR(
      executor_->SelectExecutionsByID({event.execution_id()}, &executions));
  RecordSet record_set;
  if (artifacts.records_size() == 0)
    return tensorflow::errors::InvalidArgument(
        absl::StrCat(""No artifact with the given id "", event.artifact_id()));
  if (executions.records_size() == 0)
    return tensorflow::errors::InvalidArgument(
        absl::StrCat(""No execution with the given id "", event.execution_id()));

  // insert an event and get its given id
  int64 event_time = event.has_milliseconds_since_epoch()
                         ? event.milliseconds_since_epoch()
                         : absl::ToUnixMillis(absl::Now());

  TF_RETURN_IF_ERROR(executor_->InsertEvent(event.artifact_id(),
                                            event.execution_id(), event.type(),
                                            event_time, event_id));
  // insert event paths
  for (const Event::Path::Step& step : event.path().steps()) {
    // step value oneof
    TF_RETURN_IF_ERROR(executor_->InsertEventPath(*event_id, step));
  }
  return tensorflow::Status::OK();
}

tensorflow::Status RDBMSMetadataAccessObject::FindEventsByArtifacts(
    const std::vector<int64>& artifact_ids, std::vector<Event>* events) {
  if (events == nullptr) {
    return tensorflow::errors::InvalidArgument(""Given events is NULL."");
  }

  RecordSet event_record_set;
  if (!artifact_ids.empty()) {
    TF_RETURN_IF_ERROR(
        executor_->SelectEventByArtifactIDs(artifact_ids, &event_record_set));
  }

  if (event_record_set.records_size() == 0) {
    return tensorflow::errors::NotFound(
        ""Cannot find events by given artifact ids."");
  }
  return FindEventsFromRecordSet(event_record_set, events);
}

tensorflow::Status RDBMSMetadataAccessObject::FindEventsByExecutions(
    const std::vector<int64>& execution_ids, std::vector<Event>* events) {
  if (events == nullptr) {
    return tensorflow::errors::InvalidArgument(""Given events is NULL."");
  }

  RecordSet event_record_set;
  if (!execution_ids.empty()) {
    TF_RETURN_IF_ERROR(
        executor_->SelectEventByExecutionIDs(execution_ids, &event_record_set));
  }

  if (event_record_set.records_size() == 0) {
    return tensorflow::errors::NotFound(
        ""Cannot find events by given execution ids."");
  }
  return FindEventsFromRecordSet(event_record_set, events);
}

tensorflow::Status RDBMSMetadataAccessObject::CreateAssociation(
    const Association& association, int64* association_id) {
  if (!association.has_context_id())
    return tensorflow::errors::InvalidArgument(""No context id is specified."");
  RecordSet context_id_header;
  TF_RETURN_IF_ERROR(executor_->SelectContextsByID({association.context_id()},
                                                   &context_id_header));
  if (context_id_header.records_size() == 0)
    return tensorflow::errors::InvalidArgument(""Context id not found."");

  if (!association.has_execution_id())
    return tensorflow::errors::InvalidArgument(""No execution id is specified"");
  RecordSet execution_id_header;
  TF_RETURN_IF_ERROR(executor_->SelectExecutionsByID(
      {association.execution_id()}, &execution_id_header));
  if (execution_id_header.records_size() == 0)
    return tensorflow::errors::InvalidArgument(""Execution id not found."");

  tensorflow::Status status = executor_->InsertAssociation(
      association.context_id(), association.execution_id(), association_id);

  if (IsUniqueConstraintViolated(status)) {
    return tensorflow::errors::AlreadyExists(
        ""Given association already exists: "", association.DebugString(),
        status);
  }
  return status;
}

tensorflow::Status RDBMSMetadataAccessObject::FindContextsByExecution(
    int64 execution_id, std::vector<Context>* contexts) {
  RecordSet record_set;
  TF_RETURN_IF_ERROR(
      executor_->SelectAssociationByExecutionID(execution_id, &record_set));
  const std::vector<int64> context_ids = AssociationsToContextIds(record_set);
  if (context_ids.empty()) {
    return tensorflow::errors::NotFound(
        absl::StrCat(""No contexts found for execution_id: "", execution_id));
  }
  return FindNodesImpl(context_ids, /*skipped_ids_ok=*/false, *contexts);
}

tensorflow::Status RDBMSMetadataAccessObject::FindExecutionsByContext(
    int64 context_id, std::vector<Execution>* executions) {
  std::string unused_next_page_toke;
  return FindExecutionsByContext(context_id, absl::nullopt, executions,
                                 &unused_next_page_toke);
}

tensorflow::Status RDBMSMetadataAccessObject::FindExecutionsByContext(
    int64 context_id, absl::optional<ListOperationOptions> list_options,
    std::vector<Execution>* executions, std::string* next_page_token) {
  RecordSet record_set;
  TF_RETURN_IF_ERROR(
      executor_->SelectAssociationByContextID(context_id, &record_set));
  const std::vector<int64> ids = AssociationsToExecutionIds(record_set);
  if (ids.empty()) {
    return tensorflow::Status::OK();
  }
  if (list_options.has_value()) {
    return ListNodes<Execution>(list_options.value(), ids, executions,
                                next_page_token);
  }
  return FindNodesImpl(ids, /*skipped_ids_ok=*/false, *executions);
}

tensorflow::Status RDBMSMetadataAccessObject::CreateAttribution(
    const Attribution& attribution, int64* attribution_id) {
  if (!attribution.has_context_id())
    return tensorflow::errors::InvalidArgument(""No context id is specified."");
  RecordSet context_id_header;
  TF_RETURN_IF_ERROR(executor_->SelectContextsByID({attribution.context_id()},
                                                   &context_id_header));
  if (context_id_header.records_size() == 0)
    return tensorflow::errors::InvalidArgument(""Context id not found."");

  if (!attribution.has_artifact_id())
    return tensorflow::errors::InvalidArgument(""No artifact id is specified"");
  RecordSet artifact_id_header;
  TF_RETURN_IF_ERROR(executor_->SelectArtifactsByID({attribution.artifact_id()},
                                                    &artifact_id_header));
  if (artifact_id_header.records_size() == 0)
    return tensorflow::errors::InvalidArgument(""Artifact id not found."");

  tensorflow::Status status = executor_->InsertAttributionDirect(
      attribution.context_id(), attribution.artifact_id(), attribution_id);

  if (IsUniqueConstraintViolated(status)) {
    return tensorflow::errors::AlreadyExists(
        ""Given attribution already exists: "", attribution.DebugString(),
        status);
  }
  return status;
}

tensorflow::Status RDBMSMetadataAccessObject::FindContextsByArtifact(
    int64 artifact_id, std::vector<Context>* contexts) {
  RecordSet record_set;
  TF_RETURN_IF_ERROR(
      executor_->SelectAttributionByArtifactID(artifact_id, &record_set));
  const std::vector<int64> context_ids = AttributionsToContextIds(record_set);
  if (context_ids.empty()) {
    return tensorflow::errors::NotFound(
        absl::StrCat(""No contexts found for artifact_id: "", artifact_id));
  }
  return FindNodesImpl(context_ids, /*skipped_ids_ok=*/false, *contexts);
}

tensorflow::Status RDBMSMetadataAccessObject::FindArtifactsByContext(
    int64 context_id, std::vector<Artifact>* artifacts) {
  std::string unused_next_page_token;
  return FindArtifactsByContext(context_id, absl::nullopt, artifacts,
                                &unused_next_page_token);
}

tensorflow::Status RDBMSMetadataAccessObject::FindArtifactsByContext(
    int64 context_id, absl::optional<ListOperationOptions> list_options,
    std::vector<Artifact>* artifacts, std::string* next_page_token) {
  RecordSet record_set;
  TF_RETURN_IF_ERROR(
      executor_->SelectAttributionByContextID(context_id, &record_set));
  const std::vector<int64> ids = AttributionsToArtifactIds(record_set);
  if (ids.empty()) {
    return tensorflow::Status::OK();
  }
  if (list_options.has_value()) {
    return ListNodes<Artifact>(list_options.value(), ids, artifacts,
                               next_page_token);
  }
  return FindNodesImpl(ids, /*skipped_ids_ok=*/false, *artifacts);
}

tensorflow::Status RDBMSMetadataAccessObject::CreateParentContext(
    const ParentContext& parent_context) {
  if (!parent_context.has_parent_id() || !parent_context.has_child_id()) {
    return tensorflow::errors::InvalidArgument(
        ""Missing parent / child id in the parent_context: "",
        parent_context.DebugString());
  }
  RecordSet contexts_id_header;
  TF_RETURN_IF_ERROR(executor_->SelectContextsByID(
      {parent_context.parent_id(), parent_context.child_id()},
      &contexts_id_header));
  if (contexts_id_header.records_size() < 2) {
    return tensorflow::errors::InvalidArgument(
        ""Given parent / child id in the parent_context cannot be found: "",
        parent_context.DebugString());
  }
  const tensorflow::Status status = executor_->InsertParentContext(
      parent_context.parent_id(), parent_context.child_id());
  if (IsUniqueConstraintViolated(status)) {
    return tensorflow::errors::AlreadyExists(
        ""Given parent_context already exists: "", parent_context.DebugString(),
        status);
  }
  return status;
}

tensorflow::Status RDBMSMetadataAccessObject::FindLinkedContextsImpl(
    int64 context_id, ParentContextTraverseDirection direction,
    std::vector<Context>& output_contexts) {
  RecordSet record_set;
  if (direction == ParentContextTraverseDirection::kParent) {
    TF_RETURN_IF_ERROR(
        executor_->SelectParentContextsByContextID(context_id, &record_set));
  } else if (direction == ParentContextTraverseDirection::kChild) {
    TF_RETURN_IF_ERROR(
        executor_->SelectChildContextsByContextID(context_id, &record_set));
  } else {
    return tensorflow::errors::Internal(""Unexpected ParentContext direction"");
  }
  const bool is_parent = direction == ParentContextTraverseDirection::kParent;
  const std::vector<int64> ids =
      ParentContextsToContextIds(record_set, is_parent);
  output_contexts.clear();
  if (ids.empty()) {
    return tensorflow::Status::OK();
  }
  return FindNodesImpl(ids, /*skipped_ids_ok=*/false, output_contexts);
}

tensorflow::Status RDBMSMetadataAccessObject::FindParentContextsByContextId(
    int64 context_id, std::vector<Context>* contexts) {
  if (contexts == nullptr) {
    return tensorflow::errors::InvalidArgument(""Given contexts is NULL."");
  }
  return FindLinkedContextsImpl(
      context_id, ParentContextTraverseDirection::kParent, *contexts);
}

tensorflow::Status RDBMSMetadataAccessObject::FindChildContextsByContextId(
    int64 context_id, std::vector<Context>* contexts) {
  if (contexts == nullptr) {
    return tensorflow::errors::InvalidArgument(""Given contexts is NULL."");
  }
  return FindLinkedContextsImpl(
      context_id, ParentContextTraverseDirection::kChild, *contexts);
}

tensorflow::Status RDBMSMetadataAccessObject::FindArtifacts(
    std::vector<Artifact>* artifacts) {
  RecordSet record_set;
  TF_RETURN_IF_ERROR(executor_->SelectAllArtifactIDs(&record_set));
  std::vector<int64> ids = ConvertToIds(record_set);
  if (ids.empty()) {
    return tensorflow::Status::OK();
  }
  return FindNodesImpl(ids, /*skipped_ids_ok=*/false, *artifacts);
}

template <>
tensorflow::Status RDBMSMetadataAccessObject::ListNodeIds(
    const ListOperationOptions& options,
    absl::optional<absl::Span<const int64>> candidate_ids,
    RecordSet* record_set, Artifact* tag) {
  return executor_->ListArtifactIDsUsingOptions(options, candidate_ids,
                                                record_set);
}

template <>
tensorflow::Status RDBMSMetadataAccessObject::ListNodeIds(
    const ListOperationOptions& options,
    absl::optional<absl::Span<const int64>> candidate_ids,
    RecordSet* record_set, Execution* tag) {
  return executor_->ListExecutionIDsUsingOptions(options, candidate_ids,
                                                 record_set);
}

template <>
tensorflow::Status RDBMSMetadataAccessObject::ListNodeIds(
    const ListOperationOptions& options,
    absl::optional<absl::Span<const int64>> candidate_ids,
    RecordSet* record_set, Context* tag) {
  return executor_->ListContextIDsUsingOptions(options, candidate_ids,
                                               record_set);
}

template <typename Node>
tensorflow::Status RDBMSMetadataAccessObject::ListNodes(
    const ListOperationOptions& options,
    absl::optional<absl::Span<const int64>> candidate_ids,
    std::vector<Node>* nodes, std::string* next_page_token) {
  if (options.max_result_size() <= 0) {
    return tensorflow::errors::InvalidArgument(
        absl::StrCat(""max_result_size field value is required to be greater ""
                     ""than 0 and less than or equal to 100. Set value:"",
                     options.max_result_size()));
  }
  if (!nodes->empty()) {
    return tensorflow::errors::InvalidArgument(""nodes argument is not empty"");
  }

  // Retrieving page of size 1 greater that max_result_size to detect if this
  // is the last page.
  ListOperationOptions updated_options = options;
  updated_options.set_max_result_size(options.max_result_size() + 1);
  // Retrieve ids based on the list options
  RecordSet record_set;
  TF_RETURN_IF_ERROR(
      ListNodeIds<Node>(updated_options, candidate_ids, &record_set));
  const std::vector<int64> ids = ConvertToIds(record_set);
  if (ids.empty()) {
    return tensorflow::Status::OK();
  }

  // Map node ids to positions
  absl::flat_hash_map<int64, size_t> position_by_id;
  for (int i = 0; i < ids.size(); ++i) {
    position_by_id[ids.at(i)] = i;
  }

  // Retrieve nodes
  TF_RETURN_IF_ERROR(FindNodesImpl(ids, /*skipped_ids_ok=*/false, *nodes));

  // Sort nodes in the right order
  absl::c_sort(*nodes, [&](const Node& a, const Node& b) {
    return position_by_id.at(a.id()) < position_by_id.at(b.id());
  });

  if (nodes->size() > options.max_result_size()) {
    // Removing the extra node retrieved for last page detection.
    nodes->pop_back();
    TF_RETURN_IF_ERROR(BuildListOperationNextPageToken<Node>(*nodes, options,
                                                             next_page_token));
  } else {
    *next_page_token = """";
  }
  return tensorflow::Status::OK();
}

tensorflow::Status RDBMSMetadataAccessObject::ListArtifacts(
    const ListOperationOptions& options, std::vector<Artifact>* artifacts,
    std::string* next_page_token) {
  return ListNodes<Artifact>(options, absl::nullopt, artifacts,
                             next_page_token);
}

tensorflow::Status RDBMSMetadataAccessObject::ListExecutions(
    const ListOperationOptions& options, std::vector<Execution>* executions,
    std::string* next_page_token) {
  return ListNodes<Execution>(options, absl::nullopt, executions,
                              next_page_token);
}

tensorflow::Status RDBMSMetadataAccessObject::ListContexts(
    const ListOperationOptions& options, std::vector<Context>* contexts,
    std::string* next_page_token) {
  return ListNodes<Context>(options, absl::nullopt, contexts, next_page_token);
}

tensorflow::Status
RDBMSMetadataAccessObject::FindArtifactByTypeIdAndArtifactName(
    const int64 type_id, const absl::string_view name, Artifact* artifact) {
  RecordSet record_set;
  TF_RETURN_IF_ERROR(executor_->SelectArtifactByTypeIDAndArtifactName(
      type_id, name, &record_set));
  const std::vector<int64> ids = ConvertToIds(record_set);
  if (ids.empty()) {
    return tensorflow::errors::NotFound(absl::StrCat(
        ""No artifacts found for type_id:"", type_id, "", name:"", name));
  }
  std::vector<Artifact> artifacts;
  TF_RETURN_IF_ERROR(FindNodesImpl(ids, /*skipped_ids_ok=*/false, artifacts));
  // By design, a <type_id, name> pair uniquely identifies an artifact.
  // Fails if multiple artifacts are found.
  CHECK_EQ(artifacts.size(), 1)
      << absl::StrCat(""Found more than one artifact with type_id: "", type_id,
                      "" and artifact name: "", name);
  *artifact = artifacts[0];
  return tensorflow::Status::OK();
}

tensorflow::Status RDBMSMetadataAccessObject::FindArtifactsByTypeId(
    const int64 type_id, std::vector<Artifact>* artifacts) {
  RecordSet record_set;
  TF_RETURN_IF_ERROR(executor_->SelectArtifactsByTypeID(type_id, &record_set));
  const std::vector<int64> ids = ConvertToIds(record_set);
  if (ids.empty()) {
    return tensorflow::errors::NotFound(
        absl::StrCat(""No artifacts found for type_id:"", type_id));
  }
  return FindNodesImpl(ids, /*skipped_ids_ok=*/false, *artifacts);
}

tensorflow::Status RDBMSMetadataAccessObject::FindExecutions(
    std::vector<Execution>* executions) {
  RecordSet record_set;
  TF_RETURN_IF_ERROR(executor_->SelectAllExecutionIDs(&record_set));
  const std::vector<int64> ids = ConvertToIds(record_set);
  if (ids.empty()) {
    return tensorflow::Status::OK();
  }
  return FindNodesImpl(ids, /*skipped_ids_ok=*/false, *executions);
}

tensorflow::Status
RDBMSMetadataAccessObject::FindExecutionByTypeIdAndExecutionName(
    const int64 type_id, const absl::string_view name, Execution* execution) {
  RecordSet record_set;
  TF_RETURN_IF_ERROR(executor_->SelectExecutionByTypeIDAndExecutionName(
      type_id, name, &record_set));
  const std::vector<int64> ids = ConvertToIds(record_set);
  if (ids.empty()) {
    return tensorflow::errors::NotFound(absl::StrCat(
        ""No executions found for type_id:"", type_id, "", name:"", name));
  }
  std::vector<Execution> executions;
  TF_RETURN_IF_ERROR(FindNodesImpl(ids, /*skipped_ids_ok=*/false, executions));
  // By design, a <type_id, name> pair uniquely identifies an execution.
  // Fails if multiple executions are found.
  CHECK_EQ(executions.size(), 1)
      << absl::StrCat(""Found more than one execution with type_id: "", type_id,
                      "" and execution name: "", name);
  *execution = executions[0];
  return tensorflow::Status::OK();
}

tensorflow::Status RDBMSMetadataAccessObject::FindExecutionsByTypeId(
    const int64 type_id, std::vector<Execution>* executions) {
  RecordSet record_set;
  TF_RETURN_IF_ERROR(executor_->SelectExecutionsByTypeID(type_id, &record_set));
  const std::vector<int64> ids = ConvertToIds(record_set);
  if (ids.empty()) {
    return tensorflow::errors::NotFound(
        absl::StrCat(""No executions found for type_id:"", type_id));
  }
  return FindNodesImpl(ids, /*skipped_ids_ok=*/false, *executions);
}

tensorflow::Status RDBMSMetadataAccessObject::FindContexts(
    std::vector<Context>* contexts) {
  RecordSet record_set;
  TF_RETURN_IF_ERROR(executor_->SelectAllContextIDs(&record_set));
  const std::vector<int64> ids = ConvertToIds(record_set);
  if (ids.empty()) {
    return tensorflow::Status::OK();
  }
  return FindNodesImpl(ids, /*skipped_ids_ok=*/false, *contexts);
}

tensorflow::Status RDBMSMetadataAccessObject::FindContextsByTypeId(
    const int64 type_id, absl::optional<ListOperationOptions> list_options,
    std::vector<Context>* contexts, std::string* next_page_token) {
  RecordSet record_set;
  TF_RETURN_IF_ERROR(executor_->SelectContextsByTypeID(type_id, &record_set));
  const std::vector<int64> ids = ConvertToIds(record_set);
  if (ids.empty()) {
    return tensorflow::errors::NotFound(
        absl::StrCat(""No contexts found with type_id: "", type_id));
  }

  if (list_options) {
    return ListNodes<Context>(list_options.value(), ids, contexts,
                              next_page_token);
  } else {
    return FindNodesImpl(ids, /*skipped_ids_ok=*/false, *contexts);
  }
}

tensorflow::Status RDBMSMetadataAccessObject::FindArtifactsByURI(
    const absl::string_view uri, std::vector<Artifact>* artifacts) {
  RecordSet record_set;
  TF_RETURN_IF_ERROR(executor_->SelectArtifactsByURI(uri, &record_set));
  const std::vector<int64> ids = ConvertToIds(record_set);
  if (ids.empty()) {
    return tensorflow::errors::NotFound(
        absl::StrCat(""No artifacts found for uri:"", uri));
  }
  return FindNodesImpl(ids, /*skipped_ids_ok=*/false, *artifacts);
}

tensorflow::Status RDBMSMetadataAccessObject::FindContextByTypeIdAndContextName(
    int64 type_id, absl::string_view name, Context* context) {
  RecordSet record_set;
  TF_RETURN_IF_ERROR(executor_->SelectContextByTypeIDAndContextName(
      type_id, name, &record_set));
  const std::vector<int64> ids = ConvertToIds(record_set);
  if (ids.empty()) {
    return tensorflow::errors::NotFound(absl::StrCat(
        ""No contexts found with type_id: "", type_id, "", name: "", name));
  }
  std::vector<Context> contexts;
  TF_RETURN_IF_ERROR(FindNodesImpl(ids, /*skipped_ids_ok=*/false, contexts));
  // By design, a <type_id, name> pair uniquely identifies a context.
  // Fails if multiple contexts are found.
  CHECK_EQ(contexts.size(), 1)
      << absl::StrCat(""Found more than one contexts with type_id: "", type_id,
                      "" and context name: "", name);
  *context = contexts[0];
  return tensorflow::Status::OK();
}


}  // namespace ml_metadata
",16217,True,3291.183052413872,median
"CLASS zcl_abapgit_object_wdyn DEFINITION PUBLIC INHERITING FROM zcl_abapgit_objects_super FINAL.

  PUBLIC SECTION.
    INTERFACES zif_abapgit_object.
    ALIASES mo_files FOR zif_abapgit_object~mo_files.

  PROTECTED SECTION.
  PRIVATE SECTION.

    DATA:
      mt_components TYPE TABLE OF wdy_ctlr_compo_vrs,
      mt_sources    TYPE TABLE OF wdy_ctlr_compo_source_vrs.

    METHODS:
      get_limu_objects
        RETURNING VALUE(rt_objects) TYPE wdy_md_transport_keys,
      read
        RETURNING VALUE(rs_component) TYPE wdy_component_metadata
        RAISING   zcx_abapgit_exception,
      read_controller
        IMPORTING is_key               TYPE wdy_md_controller_key
        RETURNING VALUE(rs_controller) TYPE wdy_md_controller_meta_data
        RAISING   zcx_abapgit_exception,
      read_definition
        IMPORTING is_key               TYPE wdy_md_component_key
        RETURNING VALUE(rs_definition) TYPE wdy_md_component_meta_data
        RAISING   zcx_abapgit_exception,
      read_view
        IMPORTING is_key         TYPE wdy_md_view_key
        RETURNING VALUE(rs_view) TYPE wdy_md_view_meta_data
        RAISING   zcx_abapgit_exception,
      recover_controller
        IMPORTING is_controller TYPE wdy_md_controller_meta_data
        RAISING   zcx_abapgit_exception,
      recover_definition
        IMPORTING is_definition TYPE wdy_md_component_meta_data
                  iv_package    TYPE devclass
        RAISING   zcx_abapgit_exception,
      recover_view
        IMPORTING is_view TYPE wdy_md_view_meta_data
        RAISING   zcx_abapgit_exception,
      delta_controller
        IMPORTING is_controller   TYPE wdy_md_controller_meta_data
        RETURNING VALUE(rs_delta) TYPE svrs2_xversionable_object
        RAISING   zcx_abapgit_exception,
      delta_definition
        IMPORTING is_definition     TYPE wdy_md_component_meta_data
                  VALUE(iv_package) TYPE devclass
        RETURNING VALUE(rs_delta)   TYPE svrs2_xversionable_object
        RAISING   zcx_abapgit_exception,
      delta_view
        IMPORTING is_view         TYPE wdy_md_view_meta_data
        RETURNING VALUE(rs_delta) TYPE svrs2_xversionable_object
        RAISING   zcx_abapgit_exception,
      add_fm_param_exporting
        IMPORTING iv_name  TYPE string
                  ig_value TYPE any
        CHANGING  ct_param TYPE abap_func_parmbind_tab,
      add_fm_param_tables
        IMPORTING iv_name  TYPE string
        CHANGING  ct_value TYPE ANY TABLE
                  ct_param TYPE abap_func_parmbind_tab,
      add_fm_exception
        IMPORTING iv_name      TYPE string
                  iv_value     TYPE i
        CHANGING  ct_exception TYPE abap_func_excpbind_tab.

ENDCLASS.



CLASS zcl_abapgit_object_wdyn IMPLEMENTATION.


  METHOD add_fm_exception.

    DATA: ls_exception LIKE LINE OF ct_exception.

    ls_exception-name = iv_name.
    ls_exception-value = iv_value.

    INSERT ls_exception INTO TABLE ct_exception.

  ENDMETHOD.


  METHOD add_fm_param_exporting.

    DATA: ls_param LIKE LINE OF ct_param.

    ls_param-kind = abap_func_exporting.
    ls_param-name = iv_name.
    GET REFERENCE OF ig_value INTO ls_param-value.

    INSERT ls_param INTO TABLE ct_param.

  ENDMETHOD.


  METHOD add_fm_param_tables.

    DATA: ls_param LIKE LINE OF ct_param.

    ls_param-kind = abap_func_tables.
    ls_param-name = iv_name.
    GET REFERENCE OF ct_value INTO ls_param-value.

    INSERT ls_param INTO TABLE ct_param.

  ENDMETHOD.


  METHOD delta_controller.

    DATA: li_controller TYPE REF TO if_wdy_md_controller,
          lv_found      TYPE abap_bool,
          ls_key        TYPE wdy_md_controller_key,
          ls_obj_new    TYPE svrs2_versionable_object,
          ls_obj_old    TYPE svrs2_versionable_object.

    FIELD-SYMBOLS: <ls_component>            LIKE LINE OF mt_components,
                   <ls_source>               LIKE LINE OF mt_sources,
                   <lt_ctrl_exceptions>      TYPE ANY TABLE,
                   <lt_ctrl_exception_texts> TYPE ANY TABLE,
                   <lt_excp>                 TYPE ANY TABLE,
                   <lt_excpt>                TYPE ANY TABLE.


    ls_key-component_name = is_controller-definition-component_name.
    ls_key-controller_name = is_controller-definition-controller_name.

    lv_found = cl_wdy_md_controller=>check_existency(
          component_name  = ls_key-component_name
          controller_name = ls_key-controller_name ).
    IF lv_found = abap_false.
      TRY.
          li_controller ?= cl_wdy_md_controller=>create_complete(
                component_name  = ls_key-component_name
                controller_name = ls_key-controller_name
                controller_type = is_controller-definition-controller_type ).
          li_controller->save_to_database( ).
          li_controller->unlock( ).
        CATCH cx_wdy_md_exception.
          zcx_abapgit_exception=>raise( 'error creating dummy controller' ).
      ENDTRY.
    ENDIF.

    ls_obj_new-objtype = wdyn_limu_component_controller.
    ls_obj_new-objname = ls_key.

    ls_obj_old-objtype = wdyn_limu_component_controller.
    ls_obj_old-objname = ls_key.

    APPEND is_controller-definition TO ls_obj_old-wdyc-defin.

    LOOP AT mt_components ASSIGNING <ls_component>
        WHERE component_name = ls_key-component_name
        AND controller_name = ls_key-controller_name.
      APPEND <ls_component> TO ls_obj_old-wdyc-ccomp.
    ENDLOOP.
    LOOP AT mt_sources ASSIGNING <ls_source>
        WHERE component_name = ls_key-component_name
        AND controller_name = ls_key-controller_name.
      APPEND <ls_source> TO ls_obj_old-wdyc-ccoms.
    ENDLOOP.

    ls_obj_old-wdyc-descr = is_controller-descriptions.
    ls_obj_old-wdyc-cusag = is_controller-controller_usages.
    ls_obj_old-wdyc-ccomt = is_controller-controller_component_texts.
    ls_obj_old-wdyc-cpara = is_controller-controller_parameters.
    ls_obj_old-wdyc-cpart = is_controller-controller_parameter_texts.
    ls_obj_old-wdyc-cnode = is_controller-context_nodes.
    ls_obj_old-wdyc-cattr = is_controller-context_attributes.
    ls_obj_old-wdyc-cmapp = is_controller-context_mappings.
*   Version 702 doesn't have these two attributes so we
*   use them dynamically for downward compatibility
    ASSIGN COMPONENT 'CONTROLLER_EXCEPTIONS' OF STRUCTURE is_controller
      TO <lt_ctrl_exceptions>.
    IF sy-subrc = 0.
      ASSIGN COMPONENT 'EXCP' OF STRUCTURE ls_obj_old-wdyc TO <lt_excp>.
      IF sy-subrc = 0.
        <lt_excp> = <lt_ctrl_exceptions>.
      ENDIF.
    ENDIF.
    ASSIGN COMPONENT 'CONTROLLER_EXCEPTIONS_TEXTS' OF STRUCTURE is_controller
      TO <lt_ctrl_exception_texts>.
    IF sy-subrc = 0.
      ASSIGN COMPONENT 'EXCPT' OF STRUCTURE ls_obj_old-wdyc TO <lt_excpt>.
      IF sy-subrc = 0.
        <lt_excpt> = <lt_ctrl_exception_texts>.
      ENDIF.
    ENDIF.
    ls_obj_old-wdyc-fgrps = is_controller-fieldgroups.

    CALL FUNCTION 'SVRS_MAKE_OBJECT_DELTA'
      EXPORTING
        obj_old              = ls_obj_new
        obj_new              = ls_obj_old
      CHANGING
        delta                = rs_delta
      EXCEPTIONS
        inconsistent_objects = 1.
    IF sy-subrc <> 0.
      zcx_abapgit_exception=>raise( 'error from SVRS_MAKE_OBJECT_DELTA' ).
    ENDIF.

  ENDMETHOD.


  METHOD delta_definition.

    DATA: ls_key       TYPE wdy_md_component_key,
          lv_found     TYPE abap_bool,
          ls_obj_new   TYPE svrs2_versionable_object,
          li_component TYPE REF TO if_wdy_md_component,
          ls_obj_old   TYPE svrs2_versionable_object.


    ls_key-component_name = is_definition-definition-component_name.

    lv_found = cl_wdy_md_component=>check_existency( ls_key-component_name ).
    IF lv_found = abap_false.
      TRY.
          cl_wdy_md_component=>create_complete(
            EXPORTING
              name      = ls_key-component_name
            IMPORTING
              component = li_component
            CHANGING
              devclass  = iv_package ).
          li_component->save_to_database( ).
          li_component->unlock( ).
        CATCH cx_wdy_md_exception.
          zcx_abapgit_exception=>raise( 'error creating dummy component' ).
      ENDTRY.
    ENDIF.

    ls_obj_new-objtype = wdyn_limu_component_definition.
    ls_obj_new-objname = ls_key-component_name.

    ls_obj_old-objtype = wdyn_limu_component_definition.
    ls_obj_old-objname = ls_key-component_name.

    APPEND is_definition-definition TO ls_obj_old-wdyd-defin.
    ls_obj_old-wdyd-descr = is_definition-descriptions.
    ls_obj_old-wdyd-cusag = is_definition-component_usages.
    ls_obj_old-wdyd-intrf = is_definition-interface_implementings.
    ls_obj_old-wdyd-libra = is_definition-library_usages.
    ls_obj_old-wdyd-ctuse = is_definition-ext_ctlr_usages.
    ls_obj_old-wdyd-ctmap = is_definition-ext_ctx_mappings.

    CALL FUNCTION 'SVRS_MAKE_OBJECT_DELTA'
      EXPORTING
        obj_old              = ls_obj_new
        obj_new              = ls_obj_old
      CHANGING
        delta                = rs_delta
      EXCEPTIONS
        inconsistent_objects = 1.
    IF sy-subrc <> 0.
      zcx_abapgit_exception=>raise( 'error from SVRS_MAKE_OBJECT_DELTA' ).
    ENDIF.

  ENDMETHOD.


  METHOD delta_view.

    DATA: ls_key     TYPE wdy_md_view_key,
          ls_obj_new TYPE svrs2_versionable_object,
          ls_obj_old TYPE svrs2_versionable_object,
          lv_found   TYPE abap_bool,
          li_view    TYPE REF TO if_wdy_md_abstract_view.

    FIELD-SYMBOLS: <ls_def> LIKE LINE OF ls_obj_old-wdyv-defin.


    ls_key-component_name = is_view-definition-component_name.
    ls_key-view_name      = is_view-definition-view_name.

    lv_found = cl_wdy_md_abstract_view=>check_existency(
                 component_name = ls_key-component_name
                 name           = ls_key-view_name ).
    IF lv_found = abap_false.
      TRY.
          li_view = cl_wdy_md_abstract_view=>create(
                      component_name = is_view-definition-component_name
                      view_name      = is_view-definition-view_name
                      type           = is_view-definition-type ).
          li_view->save_to_database( ).
          li_view->unlock( ).
        CATCH cx_wdy_md_exception.
          zcx_abapgit_exception=>raise( 'error creating dummy view' ).
      ENDTRY.
    ENDIF.

    ls_obj_new-objtype = wdyn_limu_component_view.
    ls_obj_new-objname = ls_key.

    ls_obj_old-objtype = wdyn_limu_component_view.
    ls_obj_old-objname = ls_key.

    APPEND INITIAL LINE TO ls_obj_old-wdyv-defin ASSIGNING <ls_def>.
    MOVE-CORRESPONDING is_view-definition TO <ls_def>.

    ls_obj_old-wdyv-descr = is_view-descriptions.
    ls_obj_old-wdyv-vcont = is_view-view_containers.
    ls_obj_old-wdyv-vcntt = is_view-view_container_texts.
    ls_obj_old-wdyv-ibplg = is_view-iobound_plugs.
    ls_obj_old-wdyv-ibplt = is_view-iobound_plug_texts.
    ls_obj_old-wdyv-plpar = is_view-plug_parameters.
    ls_obj_old-wdyv-plprt = is_view-plug_parameter_texts.
    ls_obj_old-wdyv-uiele = is_view-ui_elements.
    ls_obj_old-wdyv-uicon = is_view-ui_context_bindings.
    ls_obj_old-wdyv-uievt = is_view-ui_event_bindings.
    ls_obj_old-wdyv-uiddc = is_view-ui_ddic_bindings.
    ls_obj_old-wdyv-uiprp = is_view-ui_properties.
    ls_obj_old-wdyv-navil = is_view-navigation_links.
    ls_obj_old-wdyv-navit = is_view-navigation_target_refs.
    ls_obj_old-wdyv-vshno = is_view-vsh_nodes.
    ls_obj_old-wdyv-vshpl = is_view-vsh_placeholders.
    ls_obj_old-wdyv-views = is_view-viewset_properties.

    CALL FUNCTION 'SVRS_MAKE_OBJECT_DELTA'
      EXPORTING
        obj_old              = ls_obj_new
        obj_new              = ls_obj_old
      CHANGING
        delta                = rs_delta
      EXCEPTIONS
        inconsistent_objects = 1.
    IF sy-subrc <> 0.
      zcx_abapgit_exception=>raise( 'error from SVRS_MAKE_OBJECT_DELTA' ).
    ENDIF.

  ENDMETHOD.


  METHOD get_limu_objects.

    DATA: lv_name TYPE wdy_component_name.


    lv_name = ms_item-obj_name.
    CALL FUNCTION 'WDYN_GET_LIMU_OBJECTS'
      EXPORTING
        component_name = lv_name
      IMPORTING
        limu_objects   = rt_objects.

  ENDMETHOD.


  METHOD read.

    DATA: lt_objects        TYPE wdy_md_transport_keys,
          ls_controller_key TYPE wdy_md_controller_key,
          ls_component_key  TYPE wdy_md_component_key,
          ls_view_key       TYPE wdy_md_view_key.

    FIELD-SYMBOLS: <ls_object>               LIKE LINE OF lt_objects,
                   <ls_meta>                 LIKE LINE OF rs_component-ctlr_metadata,
                   <lt_ctrl_exceptions>      TYPE ANY TABLE,
                   <lt_ctrl_exception_texts> TYPE ANY TABLE.

    CLEAR mt_components.
    CLEAR mt_sources.

    lt_objects = get_limu_objects( ).

    LOOP AT lt_objects ASSIGNING <ls_object>.
      CASE <ls_object>-sub_type.
        WHEN wdyn_limu_component_controller.
          ls_controller_key = <ls_object>-sub_name.
          APPEND read_controller( ls_controller_key ) TO rs_component-ctlr_metadata.
        WHEN wdyn_limu_component_definition.
          ls_component_key = <ls_object>-sub_name.
          rs_component-comp_metadata = read_definition( ls_component_key ).
        WHEN wdyn_limu_component_view.
          ls_view_key = <ls_object>-sub_name.
          APPEND read_view( ls_view_key ) TO rs_component-view_metadata.
        WHEN OTHERS.
          ASSERT 0 = 1.
      ENDCASE.
    ENDLOOP.

    SORT rs_component-ctlr_metadata BY
      definition-component_name ASCENDING
      definition-controller_name ASCENDING.

    LOOP AT rs_component-ctlr_metadata ASSIGNING <ls_meta>.
      SORT <ls_meta>-descriptions.
      SORT <ls_meta>-controller_usages.
      SORT <ls_meta>-controller_components.
      SORT <ls_meta>-controller_component_texts.
      SORT <ls_meta>-controller_parameters.
      SORT <ls_meta>-controller_parameter_texts.
      SORT <ls_meta>-context_nodes.
      SORT <ls_meta>-context_attributes.
      SORT <ls_meta>-context_mappings.
      SORT <ls_meta>-fieldgroups.
*     Version 702 doesn't have these two attributes so we
*     use them dynamically for downward compatibility
      ASSIGN COMPONENT 'CONTROLLER_EXCEPTIONS' OF STRUCTURE <ls_meta> TO <lt_ctrl_exceptions>.
      IF sy-subrc = 0.
        SORT <lt_ctrl_exceptions>.
      ENDIF.
      ASSIGN COMPONENT 'CONTROLLER_EXCEPTION_TEXTS' OF STRUCTURE <ls_meta> TO <lt_ctrl_exception_texts>.
      IF sy-subrc = 0.
        SORT <lt_ctrl_exception_texts>.
      ENDIF.
    ENDLOOP.

    SORT mt_components BY
      component_name ASCENDING
      controller_name ASCENDING
      cmpname ASCENDING.

    SORT mt_sources BY
      component_name ASCENDING
      controller_name ASCENDING
      cmpname ASCENDING
      line_number ASCENDING.

  ENDMETHOD.


  METHOD read_controller.

    DATA: lt_components   TYPE TABLE OF wdy_ctlr_compo_vrs,
          lt_sources      TYPE TABLE OF wdy_ctlr_compo_source_vrs,
          lt_definition   TYPE TABLE OF wdy_controller,
          lt_psmodilog    TYPE TABLE OF smodilog,
          lt_psmodisrc    TYPE TABLE OF smodisrc,
          lt_fm_param     TYPE abap_func_parmbind_tab,
          lt_fm_exception TYPE abap_func_excpbind_tab.

    FIELD-SYMBOLS: <lt_ctrl_exceptions>      TYPE ANY TABLE,
                   <lt_ctrl_exception_texts> TYPE ANY TABLE.

*   Calling FM dynamically because version 702 has less parameters

*   FM parameters
    add_fm_param_exporting( EXPORTING iv_name     = 'CONTROLLER_KEY'
                                      ig_value    = is_key
                            CHANGING  ct_param = lt_fm_param ).
    add_fm_param_exporting( EXPORTING iv_name     = 'GET_ALL_TRANSLATIONS'
                                      ig_value    = abap_false
                            CHANGING  ct_param = lt_fm_param ).
    add_fm_param_tables( EXPORTING iv_name = 'DEFINITION'
                         CHANGING  ct_value = lt_definition
                                   ct_param = lt_fm_param ).
    add_fm_param_tables( EXPORTING iv_name = 'DESCRIPTIONS'
                         CHANGING ct_value = rs_controller-descriptions
                                  ct_param = lt_fm_param ).
    add_fm_param_tables( EXPORTING iv_name = 'CONTROLLER_USAGES'
                         CHANGING ct_value = rs_controller-controller_usages
                                  ct_param = lt_fm_param ).
    add_fm_param_tables( EXPORTING iv_name = 'CONTROLLER_COMPONENTS'
                         CHANGING ct_value = lt_components
                                  ct_param = lt_fm_param ).
    add_fm_param_tables( EXPORTING iv_name = 'CONTROLLER_COMPONENT_SOURCES'
                         CHANGING ct_value = lt_sources
                                  ct_param = lt_fm_param ).
    add_fm_param_tables( EXPORTING iv_name = 'CONTROLLER_COMPONENT_TEXTS'
                         CHANGING ct_value = rs_controller-controller_component_texts
                                  ct_param = lt_fm_param ).
    add_fm_param_tables( EXPORTING iv_name = 'CONTROLLER_PARAMETERS'
                         CHANGING ct_value = rs_controller-controller_parameters
                                  ct_param = lt_fm_param ).
    add_fm_param_tables( EXPORTING iv_name = 'CONTROLLER_PARAMETER_TEXTS'
                         CHANGING ct_value = rs_controller-controller_parameter_texts
                                  ct_param = lt_fm_param ).
    add_fm_param_tables( EXPORTING iv_name = 'CONTEXT_NODES'
                         CHANGING ct_value = rs_controller-context_nodes
                                  ct_param = lt_fm_param ).
    add_fm_param_tables( EXPORTING iv_name = 'CONTEXT_ATTRIBUTES'
                         CHANGING ct_value = rs_controller-context_attributes
                                  ct_param = lt_fm_param ).
    add_fm_param_tables( EXPORTING iv_name = 'CONTEXT_MAPPINGS'
                         CHANGING ct_value = rs_controller-context_mappings
                                  ct_param = lt_fm_param ).
    add_fm_param_tables( EXPORTING iv_name = 'FIELDGROUPS'
                         CHANGING ct_value = rs_controller-fieldgroups
                                  ct_param = lt_fm_param ).
*   Version 702 doesn't have these two attributes so we
*   use them dynamically for downward compatibility
    ASSIGN COMPONENT 'CONTROLLER_EXCEPTIONS' OF STRUCTURE rs_controller TO <lt_ctrl_exceptions>.
    IF sy-subrc = 0.
      add_fm_param_tables( EXPORTING iv_name = 'CONTROLLER_EXCEPTIONS'
                           CHANGING ct_value = <lt_ctrl_exceptions>
                                    ct_param = lt_fm_param ).
    ENDIF.
    ASSIGN COMPONENT 'CONTROLLER_EXCEPTION_TEXTS' OF STRUCTURE rs_controller TO <lt_ctrl_exception_texts>.
    IF sy-subrc = 0.
      add_fm_param_tables( EXPORTING iv_name = 'CONTROLLER_EXCEPTION_TEXTS'
                           CHANGING ct_value = <lt_ctrl_exception_texts>
                                    ct_param = lt_fm_param ).
    ENDIF.
    add_fm_param_tables( EXPORTING iv_name = 'PSMODILOG'
                         CHANGING ct_value = lt_psmodilog
                                  ct_param = lt_fm_param ).
    add_fm_param_tables( EXPORTING iv_name = 'PSMODISRC'
                         CHANGING ct_value = lt_psmodisrc
                                  ct_param = lt_fm_param ).

*   FM exceptions
    add_fm_exception( EXPORTING iv_name = 'NOT_EXISTING'
                                iv_value = 1
                      CHANGING ct_exception = lt_fm_exception ).
    add_fm_exception( EXPORTING iv_name = 'OTHERS'
                                iv_value = 2
                      CHANGING ct_exception = lt_fm_exception ).

    CALL FUNCTION 'WDYC_GET_OBJECT'
      PARAMETER-TABLE
      lt_fm_param
      EXCEPTION-TABLE
      lt_fm_exception.
    IF sy-subrc <> 0.
      zcx_abapgit_exception=>raise( 'error from WDYC_GET_OBJECT' ).
    ENDIF.

    APPEND LINES OF lt_components TO mt_components.
    APPEND LINES OF lt_sources TO mt_sources.

    READ TABLE lt_definition INDEX 1 INTO rs_controller-definition.
    IF sy-subrc <> 0.
      zcx_abapgit_exception=>raise( 'WDYC, definition not found' ).
    ENDIF.

    CLEAR: rs_controller-definition-author,
           rs_controller-definition-createdon,
           rs_controller-definition-changedby,
           rs_controller-definition-changedon.

  ENDMETHOD.


  METHOD read_definition.

    DATA: lt_definition TYPE TABLE OF wdy_component,
          lt_psmodilog  TYPE TABLE OF smodilog,
          lt_psmodisrc  TYPE TABLE OF smodisrc.


    CALL FUNCTION 'WDYD_GET_OBJECT'
      EXPORTING
        component_key           = is_key
        get_all_translations    = abap_false
      TABLES
        definition              = lt_definition
        descriptions            = rs_definition-descriptions
        component_usages        = rs_definition-component_usages
        interface_implementings = rs_definition-interface_implementings
        library_usages          = rs_definition-library_usages
        ext_ctlr_usages         = rs_definition-ext_ctlr_usages
        ext_ctx_mappings        = rs_definition-ext_ctx_mappings
        psmodilog               = lt_psmodilog "" not optional in all versions
        psmodisrc               = lt_psmodisrc "" not optional in all versions
      EXCEPTIONS
        not_existing            = 1
        OTHERS                  = 2.
    IF sy-subrc = 1.
      RETURN.
    ELSEIF sy-subrc <> 0.
      zcx_abapgit_exception=>raise( 'error from WDYD_GET_OBJECT' ).
    ENDIF.

    READ TABLE lt_definition INDEX 1 INTO rs_definition-definition.
    IF sy-subrc <> 0.
      zcx_abapgit_exception=>raise( 'WDYD, definition not found' ).
    ENDIF.

    CLEAR: rs_definition-definition-author,
           rs_definition-definition-createdon,
           rs_definition-definition-changedby,
           rs_definition-definition-changedon,
           rs_definition-definition-gendate,
           rs_definition-definition-gentime.

  ENDMETHOD.


  METHOD read_view.

    DATA: lt_definition TYPE TABLE OF wdy_view_vrs,
          lt_psmodilog  TYPE TABLE OF smodilog,
          lt_psmodisrc  TYPE TABLE OF smodisrc.

    FIELD-SYMBOLS: <ls_definition> LIKE LINE OF lt_definition.


    CALL FUNCTION 'WDYV_GET_OBJECT'
      EXPORTING
        view_key               = is_key
        get_all_translations   = abap_false
      TABLES
        definition             = lt_definition
        descriptions           = rs_view-descriptions
        view_containers        = rs_view-view_containers
        view_container_texts   = rs_view-view_container_texts
        iobound_plugs          = rs_view-iobound_plugs
        iobound_plug_texts     = rs_view-iobound_plug_texts
        plug_parameters        = rs_view-plug_parameters
        plug_parameter_texts   = rs_view-plug_parameter_texts
        ui_elements            = rs_view-ui_elements
        ui_context_bindings    = rs_view-ui_context_bindings
        ui_event_bindings      = rs_view-ui_event_bindings
        ui_ddic_bindings       = rs_view-ui_ddic_bindings
        ui_properties          = rs_view-ui_properties
        navigation_links       = rs_view-navigation_links
        navigation_target_refs = rs_view-navigation_target_refs
        vsh_nodes              = rs_view-vsh_nodes
        vsh_placeholders       = rs_view-vsh_placeholders
        viewset_properties     = rs_view-viewset_properties
        psmodilog              = lt_psmodilog
        psmodisrc              = lt_psmodisrc
      EXCEPTIONS
        not_existing           = 1
        OTHERS                 = 2.
    IF sy-subrc <> 0.
      zcx_abapgit_exception=>raise( 'error from WDYV_GET_OBJECT' ).
    ENDIF.

    READ TABLE lt_definition INDEX 1 ASSIGNING <ls_definition>.
    ASSERT sy-subrc = 0.
    MOVE-CORRESPONDING <ls_definition> TO rs_view-definition.

    CLEAR: rs_view-definition-author,
           rs_view-definition-createdon,
           rs_view-definition-changedby,
           rs_view-definition-changedon.

  ENDMETHOD.


  METHOD recover_controller.

    DATA: ls_key    TYPE wdy_controller_key,
          lv_corrnr TYPE trkorr,
          ls_delta  TYPE svrs2_xversionable_object.


    ls_delta = delta_controller( is_controller ).
    ls_key-component_name  = is_controller-definition-component_name.
    ls_key-controller_name = is_controller-definition-controller_name.

    TRY.
        cl_wdy_md_controller=>recover_version(
          EXPORTING
            controller_key = ls_key
            delta          = ls_delta-wdyc
          CHANGING
            corrnr         = lv_corrnr ).
      CATCH cx_wdy_md_exception.
        zcx_abapgit_exception=>raise( 'error recovering version of controller' ).
    ENDTRY.

  ENDMETHOD.


  METHOD recover_definition.

    DATA: ls_key    TYPE wdy_md_component_key,
          lv_corrnr TYPE trkorr,
          ls_delta  TYPE svrs2_xversionable_object.


    ls_delta = delta_definition(
      is_definition = is_definition
      iv_package    = iv_package ).

    ls_key-component_name = is_definition-definition-component_name.

    TRY.
        cl_wdy_md_component=>recover_version(
          EXPORTING
            component_key = ls_key
            delta         = ls_delta-wdyd
          CHANGING
            corrnr        = lv_corrnr ).
      CATCH cx_wdy_md_exception.
        zcx_abapgit_exception=>raise( 'error recovering version of component' ).
    ENDTRY.

  ENDMETHOD.


  METHOD recover_view.

    DATA: ls_key    TYPE wdy_md_view_key,
          lv_corrnr TYPE trkorr,
          ls_delta  TYPE svrs2_xversionable_object.


    ls_delta = delta_view( is_view ).
    ls_key-component_name = is_view-definition-component_name.
    ls_key-view_name      = is_view-definition-view_name.

    TRY.
        cl_wdy_md_abstract_view=>recover_version(
          EXPORTING
            view_key = ls_key
            delta    = ls_delta-wdyv
          CHANGING
            corrnr   = lv_corrnr ).
      CATCH cx_wdy_md_exception.
        zcx_abapgit_exception=>raise( 'error recovering version of abstract view' ).
    ENDTRY.

  ENDMETHOD.


  METHOD zif_abapgit_object~changed_by.
    rv_user = c_user_unknown. "" todo
  ENDMETHOD.


  METHOD zif_abapgit_object~delete.

    DATA: lo_component   TYPE REF TO cl_wdy_wb_component,
          lo_request     TYPE REF TO cl_wb_request,
          li_state       TYPE REF TO if_wb_program_state,
          lv_object_name TYPE seu_objkey.


    CREATE OBJECT lo_component.

    lv_object_name = ms_item-obj_name.
    CREATE OBJECT lo_request
      EXPORTING
        p_object_type = 'YC'
        p_object_name = lv_object_name
        p_operation   = swbm_c_op_delete_no_dialog.

    lo_component->if_wb_program~process_wb_request(
      p_wb_request       = lo_request
      p_wb_program_state = li_state ).

  ENDMETHOD.


  METHOD zif_abapgit_object~deserialize.

    DATA: ls_component TYPE wdy_component_metadata.

    FIELD-SYMBOLS: <ls_view>       LIKE LINE OF ls_component-view_metadata,
                   <ls_controller> LIKE LINE OF ls_component-ctlr_metadata.


    io_xml->read( EXPORTING iv_name = 'COMPONENT'
                  CHANGING cg_data = ls_component ).
    io_xml->read( EXPORTING iv_name  = 'COMPONENTS'
                  CHANGING cg_data = mt_components ).
    io_xml->read( EXPORTING iv_name  = 'SOURCES'
                  CHANGING cg_data = mt_sources ).

    ls_component-comp_metadata-definition-author = sy-uname.
    ls_component-comp_metadata-definition-createdon = sy-datum.
    recover_definition( is_definition = ls_component-comp_metadata
                        iv_package    = iv_package ).

    LOOP AT ls_component-ctlr_metadata ASSIGNING <ls_controller>.
      <ls_controller>-definition-author = sy-uname.
      <ls_controller>-definition-createdon = sy-datum.
      recover_controller( <ls_controller> ).
    ENDLOOP.
    LOOP AT ls_component-view_metadata ASSIGNING <ls_view>.
      <ls_view>-definition-author = sy-uname.
      <ls_view>-definition-createdon = sy-datum.
      recover_view( <ls_view> ).
    ENDLOOP.

    zcl_abapgit_objects_activation=>add_item( ms_item ).

  ENDMETHOD.


  METHOD zif_abapgit_object~exists.

    DATA: lv_component_name TYPE wdy_component-component_name.


    SELECT SINGLE component_name FROM wdy_component
      INTO lv_component_name
      WHERE component_name = ms_item-obj_name
      AND version = 'A'.                                ""#EC CI_GENBUFF
    rv_bool = boolc( sy-subrc = 0 ).

  ENDMETHOD.


  METHOD zif_abapgit_object~get_comparator.
    RETURN.
  ENDMETHOD.


  METHOD zif_abapgit_object~get_deserialize_steps.
    APPEND zif_abapgit_object=>gc_step_id-abap TO rt_steps.
  ENDMETHOD.


  METHOD zif_abapgit_object~get_metadata.
    rs_metadata = get_metadata( ).
  ENDMETHOD.


  METHOD zif_abapgit_object~is_active.
    rv_active = is_active( ).
  ENDMETHOD.


  METHOD zif_abapgit_object~is_locked.
    rv_is_locked = abap_false.
  ENDMETHOD.


  METHOD zif_abapgit_object~jump.

    CALL FUNCTION 'RS_TOOL_ACCESS'
      EXPORTING
        operation     = 'SHOW'
        object_name   = ms_item-obj_name
        object_type   = ms_item-obj_type
        in_new_window = abap_true.

  ENDMETHOD.


  METHOD zif_abapgit_object~serialize.

    DATA: ls_component TYPE wdy_component_metadata.


    ls_component = read( ).

    io_xml->add( iv_name = 'COMPONENT'
                 ig_data = ls_component ).
    io_xml->add( ig_data = mt_components
                 iv_name = 'COMPONENTS' ).
    io_xml->add( ig_data = mt_sources
                 iv_name = 'SOURCES' ).

  ENDMETHOD.
ENDCLASS.
",6873,False,1436.5037486718318,median
"//===- InstCombineLoadStoreAlloca.cpp -------------------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the visit functions for load, store and alloca.
//
//===----------------------------------------------------------------------===//

#include ""InstCombineInternal.h""
#include ""llvm/ADT/MapVector.h""
#include ""llvm/ADT/SmallString.h""
#include ""llvm/ADT/Statistic.h""
#include ""llvm/Analysis/Loads.h""
#include ""llvm/Transforms/Utils/Local.h""
#include ""llvm/IR/ConstantRange.h""
#include ""llvm/IR/DataLayout.h""
#include ""llvm/IR/IntrinsicInst.h""
#include ""llvm/IR/LLVMContext.h""
#include ""llvm/IR/MDBuilder.h""
#include ""llvm/IR/PatternMatch.h""
#include ""llvm/Transforms/Utils/BasicBlockUtils.h""
using namespace llvm;
using namespace PatternMatch;

#define DEBUG_TYPE ""instcombine""

STATISTIC(NumDeadStore,    ""Number of dead stores eliminated"");
STATISTIC(NumGlobalCopies, ""Number of allocas copied from constant global"");

/// pointsToConstantGlobal - Return true if V (possibly indirectly) points to
/// some part of a constant global variable.  This intentionally only accepts
/// constant expressions because we can't rewrite arbitrary instructions.
static bool pointsToConstantGlobal(Value *V) {
  if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
    return GV->isConstant();

  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
    if (CE->getOpcode() == Instruction::BitCast ||
        CE->getOpcode() == Instruction::AddrSpaceCast ||
        CE->getOpcode() == Instruction::GetElementPtr)
      return pointsToConstantGlobal(CE->getOperand(0));
  }
  return false;
}

/// isOnlyCopiedFromConstantGlobal - Recursively walk the uses of a (derived)
/// pointer to an alloca.  Ignore any reads of the pointer, return false if we
/// see any stores or other unknown uses.  If we see pointer arithmetic, keep
/// track of whether it moves the pointer (with IsOffset) but otherwise traverse
/// the uses.  If we see a memcpy/memmove that targets an unoffseted pointer to
/// the alloca, and if the source pointer is a pointer to a constant global, we
/// can optimize this.
static bool
isOnlyCopiedFromConstantGlobal(Value *V, MemTransferInst *&TheCopy,
                               SmallVectorImpl<Instruction *> &ToDelete) {
  // We track lifetime intrinsics as we encounter them.  If we decide to go
  // ahead and replace the value with the global, this lets the caller quickly
  // eliminate the markers.

  SmallVector<std::pair<Value *, bool>, 35> ValuesToInspect;
  ValuesToInspect.emplace_back(V, false);
  while (!ValuesToInspect.empty()) {
    auto ValuePair = ValuesToInspect.pop_back_val();
    const bool IsOffset = ValuePair.second;
    for (auto &U : ValuePair.first->uses()) {
      auto *I = cast<Instruction>(U.getUser());

      if (auto *LI = dyn_cast<LoadInst>(I)) {
        // Ignore non-volatile loads, they are always ok.
        if (!LI->isSimple()) return false;
        continue;
      }

      if (isa<BitCastInst>(I) || isa<AddrSpaceCastInst>(I)) {
        // If uses of the bitcast are ok, we are ok.
        ValuesToInspect.emplace_back(I, IsOffset);
        continue;
      }
      if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) {
        // If the GEP has all zero indices, it doesn't offset the pointer. If it
        // doesn't, it does.
        ValuesToInspect.emplace_back(I, IsOffset || !GEP->hasAllZeroIndices());
        continue;
      }

      if (auto CS = CallSite(I)) {
        // If this is the function being called then we treat it like a load and
        // ignore it.
        if (CS.isCallee(&U))
          continue;

        unsigned DataOpNo = CS.getDataOperandNo(&U);
        bool IsArgOperand = CS.isArgOperand(&U);

        // Inalloca arguments are clobbered by the call.
        if (IsArgOperand && CS.isInAllocaArgument(DataOpNo))
          return false;

        // If this is a readonly/readnone call site, then we know it is just a
        // load (but one that potentially returns the value itself), so we can
        // ignore it if we know that the value isn't captured.
        if (CS.onlyReadsMemory() &&
            (CS.getInstruction()->use_empty() || CS.doesNotCapture(DataOpNo)))
          continue;

        // If this is being passed as a byval argument, the caller is making a
        // copy, so it is only a read of the alloca.
        if (IsArgOperand && CS.isByValArgument(DataOpNo))
          continue;
      }

      // Lifetime intrinsics can be handled by the caller.
      if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
        if (II->getIntrinsicID() == Intrinsic::lifetime_start ||
            II->getIntrinsicID() == Intrinsic::lifetime_end) {
          assert(II->use_empty() && ""Lifetime markers have no result to use!"");
          ToDelete.push_back(II);
          continue;
        }
      }

      // If this is isn't our memcpy/memmove, reject it as something we can't
      // handle.
      MemTransferInst *MI = dyn_cast<MemTransferInst>(I);
      if (!MI)
        return false;

      // If the transfer is using the alloca as a source of the transfer, then
      // ignore it since it is a load (unless the transfer is volatile).
      if (U.getOperandNo() == 1) {
        if (MI->isVolatile()) return false;
        continue;
      }

      // If we already have seen a copy, reject the second one.
      if (TheCopy) return false;

      // If the pointer has been offset from the start of the alloca, we can't
      // safely handle this.
      if (IsOffset) return false;

      // If the memintrinsic isn't using the alloca as the dest, reject it.
      if (U.getOperandNo() != 0) return false;

      // If the source of the memcpy/move is not a constant global, reject it.
      if (!pointsToConstantGlobal(MI->getSource()))
        return false;

      // Otherwise, the transform is safe.  Remember the copy instruction.
      TheCopy = MI;
    }
  }
  return true;
}

/// isOnlyCopiedFromConstantGlobal - Return true if the specified alloca is only
/// modified by a copy from a constant global.  If we can prove this, we can
/// replace any uses of the alloca with uses of the global directly.
static MemTransferInst *
isOnlyCopiedFromConstantGlobal(AllocaInst *AI,
                               SmallVectorImpl<Instruction *> &ToDelete) {
  MemTransferInst *TheCopy = nullptr;
  if (isOnlyCopiedFromConstantGlobal(AI, TheCopy, ToDelete))
    return TheCopy;
  return nullptr;
}

/// Returns true if V is dereferenceable for size of alloca.
static bool isDereferenceableForAllocaSize(const Value *V, const AllocaInst *AI,
                                           const DataLayout &DL) {
  if (AI->isArrayAllocation())
    return false;
  uint64_t AllocaSize = DL.getTypeStoreSize(AI->getAllocatedType());
  if (!AllocaSize)
    return false;
  return isDereferenceableAndAlignedPointer(V, AI->getAlignment(),
                                            APInt(64, AllocaSize), DL);
}

static Instruction *simplifyAllocaArraySize(InstCombiner &IC, AllocaInst &AI) {
  // Check for array size of 1 (scalar allocation).
  if (!AI.isArrayAllocation()) {
    // i32 1 is the canonical array size for scalar allocations.
    if (AI.getArraySize()->getType()->isIntegerTy(32))
      return nullptr;

    // Canonicalize it.
    Value *V = IC.Builder.getInt32(1);
    AI.setOperand(0, V);
    return &AI;
  }

  // Convert: alloca Ty, C - where C is a constant != 1 into: alloca [C x Ty], 1
  if (const ConstantInt *C = dyn_cast<ConstantInt>(AI.getArraySize())) {
    Type *NewTy = ArrayType::get(AI.getAllocatedType(), C->getZExtValue());
    AllocaInst *New = IC.Builder.CreateAlloca(NewTy, nullptr, AI.getName());
    New->setAlignment(AI.getAlignment());

    // Scan to the end of the allocation instructions, to skip over a block of
    // allocas if possible...also skip interleaved debug info
    //
    BasicBlock::iterator It(New);
    while (isa<AllocaInst>(*It) || isa<DbgInfoIntrinsic>(*It))
      ++It;

    // Now that I is pointing to the first non-allocation-inst in the block,
    // insert our getelementptr instruction...
    //
    Type *IdxTy = IC.getDataLayout().getIntPtrType(AI.getType());
    Value *NullIdx = Constant::getNullValue(IdxTy);
    Value *Idx[2] = {NullIdx, NullIdx};
    Instruction *GEP =
        GetElementPtrInst::CreateInBounds(New, Idx, New->getName() + "".sub"");
    IC.InsertNewInstBefore(GEP, *It);

    // Now make everything use the getelementptr instead of the original
    // allocation.
    return IC.replaceInstUsesWith(AI, GEP);
  }

  if (isa<UndefValue>(AI.getArraySize()))
    return IC.replaceInstUsesWith(AI, Constant::getNullValue(AI.getType()));

  // Ensure that the alloca array size argument has type intptr_t, so that
  // any casting is exposed early.
  Type *IntPtrTy = IC.getDataLayout().getIntPtrType(AI.getType());
  if (AI.getArraySize()->getType() != IntPtrTy) {
    Value *V = IC.Builder.CreateIntCast(AI.getArraySize(), IntPtrTy, false);
    AI.setOperand(0, V);
    return &AI;
  }

  return nullptr;
}

namespace {
// If I and V are pointers in different address space, it is not allowed to
// use replaceAllUsesWith since I and V have different types. A
// non-target-specific transformation should not use addrspacecast on V since
// the two address space may be disjoint depending on target.
//
// This class chases down uses of the old pointer until reaching the load
// instructions, then replaces the old pointer in the load instructions with
// the new pointer. If during the chasing it sees bitcast or GEP, it will
// create new bitcast or GEP with the new pointer and use them in the load
// instruction.
class PointerReplacer {
public:
  PointerReplacer(InstCombiner &IC) : IC(IC) {}
  void replacePointer(Instruction &I, Value *V);

private:
  void findLoadAndReplace(Instruction &I);
  void replace(Instruction *I);
  Value *getReplacement(Value *I);

  SmallVector<Instruction *, 4> Path;
  MapVector<Value *, Value *> WorkMap;
  InstCombiner &IC;
};
} // end anonymous namespace

void PointerReplacer::findLoadAndReplace(Instruction &I) {
  for (auto U : I.users()) {
    auto *Inst = dyn_cast<Instruction>(&*U);
    if (!Inst)
      return;
    LLVM_DEBUG(dbgs() << ""Found pointer user: "" << *U << '\\n');
    if (isa<LoadInst>(Inst)) {
      for (auto P : Path)
        replace(P);
      replace(Inst);
    } else if (isa<GetElementPtrInst>(Inst) || isa<BitCastInst>(Inst)) {
      Path.push_back(Inst);
      findLoadAndReplace(*Inst);
      Path.pop_back();
    } else {
      return;
    }
  }
}

Value *PointerReplacer::getReplacement(Value *V) {
  auto Loc = WorkMap.find(V);
  if (Loc != WorkMap.end())
    return Loc->second;
  return nullptr;
}

void PointerReplacer::replace(Instruction *I) {
  if (getReplacement(I))
    return;

  if (auto *LT = dyn_cast<LoadInst>(I)) {
    auto *V = getReplacement(LT->getPointerOperand());
    assert(V && ""Operand not replaced"");
    auto *NewI = new LoadInst(V);
    NewI->takeName(LT);
    IC.InsertNewInstWith(NewI, *LT);
    IC.replaceInstUsesWith(*LT, NewI);
    WorkMap[LT] = NewI;
  } else if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) {
    auto *V = getReplacement(GEP->getPointerOperand());
    assert(V && ""Operand not replaced"");
    SmallVector<Value *, 8> Indices;
    Indices.append(GEP->idx_begin(), GEP->idx_end());
    auto *NewI = GetElementPtrInst::Create(
        V->getType()->getPointerElementType(), V, Indices);
    IC.InsertNewInstWith(NewI, *GEP);
    NewI->takeName(GEP);
    WorkMap[GEP] = NewI;
  } else if (auto *BC = dyn_cast<BitCastInst>(I)) {
    auto *V = getReplacement(BC->getOperand(0));
    assert(V && ""Operand not replaced"");
    auto *NewT = PointerType::get(BC->getType()->getPointerElementType(),
                                  V->getType()->getPointerAddressSpace());
    auto *NewI = new BitCastInst(V, NewT);
    IC.InsertNewInstWith(NewI, *BC);
    NewI->takeName(BC);
    WorkMap[BC] = NewI;
  } else {
    llvm_unreachable(""should never reach here"");
  }
}

void PointerReplacer::replacePointer(Instruction &I, Value *V) {
#ifndef NDEBUG
  auto *PT = cast<PointerType>(I.getType());
  auto *NT = cast<PointerType>(V->getType());
  assert(PT != NT && PT->getElementType() == NT->getElementType() &&
         ""Invalid usage"");
#endif
  WorkMap[&I] = V;
  findLoadAndReplace(I);
}

Instruction *InstCombiner::visitAllocaInst(AllocaInst &AI) {
  if (auto *I = simplifyAllocaArraySize(*this, AI))
    return I;

  if (AI.getAllocatedType()->isSized()) {
    // If the alignment is 0 (unspecified), assign it the preferred alignment.
    if (AI.getAlignment() == 0)
      AI.setAlignment(DL.getPrefTypeAlignment(AI.getAllocatedType()));

    // Move all alloca's of zero byte objects to the entry block and merge them
    // together.  Note that we only do this for alloca's, because malloc should
    // allocate and return a unique pointer, even for a zero byte allocation.
    if (DL.getTypeAllocSize(AI.getAllocatedType()) == 0) {
      // For a zero sized alloca there is no point in doing an array allocation.
      // This is helpful if the array size is a complicated expression not used
      // elsewhere.
      if (AI.isArrayAllocation()) {
        AI.setOperand(0, ConstantInt::get(AI.getArraySize()->getType(), 1));
        return &AI;
      }

      // Get the first instruction in the entry block.
      BasicBlock &EntryBlock = AI.getParent()->getParent()->getEntryBlock();
      Instruction *FirstInst = EntryBlock.getFirstNonPHIOrDbg();
      if (FirstInst != &AI) {
        // If the entry block doesn't start with a zero-size alloca then move
        // this one to the start of the entry block.  There is no problem with
        // dominance as the array size was forced to a constant earlier already.
        AllocaInst *EntryAI = dyn_cast<AllocaInst>(FirstInst);
        if (!EntryAI || !EntryAI->getAllocatedType()->isSized() ||
            DL.getTypeAllocSize(EntryAI->getAllocatedType()) != 0) {
          AI.moveBefore(FirstInst);
          return &AI;
        }

        // If the alignment of the entry block alloca is 0 (unspecified),
        // assign it the preferred alignment.
        if (EntryAI->getAlignment() == 0)
          EntryAI->setAlignment(
              DL.getPrefTypeAlignment(EntryAI->getAllocatedType()));
        // Replace this zero-sized alloca with the one at the start of the entry
        // block after ensuring that the address will be aligned enough for both
        // types.
        unsigned MaxAlign = std::max(EntryAI->getAlignment(),
                                     AI.getAlignment());
        EntryAI->setAlignment(MaxAlign);
        if (AI.getType() != EntryAI->getType())
          return new BitCastInst(EntryAI, AI.getType());
        return replaceInstUsesWith(AI, EntryAI);
      }
    }
  }

  if (AI.getAlignment()) {
    // Check to see if this allocation is only modified by a memcpy/memmove from
    // a constant global whose alignment is equal to or exceeds that of the
    // allocation.  If this is the case, we can change all users to use
    // the constant global instead.  This is commonly produced by the CFE by
    // constructs like ""void foo() { int A[] = {1,2,3,4,5,6,7,8,9...}; }"" if 'A'
    // is only subsequently read.
    SmallVector<Instruction *, 4> ToDelete;
    if (MemTransferInst *Copy = isOnlyCopiedFromConstantGlobal(&AI, ToDelete)) {
      unsigned SourceAlign = getOrEnforceKnownAlignment(
          Copy->getSource(), AI.getAlignment(), DL, &AI, &AC, &DT);
      if (AI.getAlignment() <= SourceAlign &&
          isDereferenceableForAllocaSize(Copy->getSource(), &AI, DL)) {
        LLVM_DEBUG(dbgs() << ""Found alloca equal to global: "" << AI << '\\n');
        LLVM_DEBUG(dbgs() << ""  memcpy = "" << *Copy << '\\n');
        for (unsigned i = 0, e = ToDelete.size(); i != e; ++i)
          eraseInstFromFunction(*ToDelete[i]);
        Constant *TheSrc = cast<Constant>(Copy->getSource());
        auto *SrcTy = TheSrc->getType();
        auto *DestTy = PointerType::get(AI.getType()->getPointerElementType(),
                                        SrcTy->getPointerAddressSpace());
        Constant *Cast =
            ConstantExpr::getPointerBitCastOrAddrSpaceCast(TheSrc, DestTy);
        if (AI.getType()->getPointerAddressSpace() ==
            SrcTy->getPointerAddressSpace()) {
          Instruction *NewI = replaceInstUsesWith(AI, Cast);
          eraseInstFromFunction(*Copy);
          ++NumGlobalCopies;
          return NewI;
        } else {
          PointerReplacer PtrReplacer(*this);
          PtrReplacer.replacePointer(AI, Cast);
          ++NumGlobalCopies;
        }
      }
    }
  }

  // At last, use the generic allocation site handler to aggressively remove
  // unused allocas.
  return visitAllocSite(AI);
}

// Are we allowed to form a atomic load or store of this type?
static bool isSupportedAtomicType(Type *Ty) {
  return Ty->isIntOrPtrTy() || Ty->isFloatingPointTy();
}

/// Helper to combine a load to a new type.
///
/// This just does the work of combining a load to a new type. It handles
/// metadata, etc., and returns the new instruction. The \\c NewTy should be the
/// loaded *value* type. This will convert it to a pointer, cast the operand to
/// that pointer type, load it, etc.
///
/// Note that this will create all of the instructions with whatever insert
/// point the \\c InstCombiner currently is using.
static LoadInst *combineLoadToNewType(InstCombiner &IC, LoadInst &LI, Type *NewTy,
                                      const Twine &Suffix = """") {
  assert((!LI.isAtomic() || isSupportedAtomicType(NewTy)) &&
         ""can't fold an atomic load to requested type"");

  Value *Ptr = LI.getPointerOperand();
  unsigned AS = LI.getPointerAddressSpace();
  SmallVector<std::pair<unsigned, MDNode *>, 8> MD;
  LI.getAllMetadata(MD);

  Value *NewPtr = nullptr;
  if (!(match(Ptr, m_BitCast(m_Value(NewPtr))) &&
        NewPtr->getType()->getPointerElementType() == NewTy &&
        NewPtr->getType()->getPointerAddressSpace() == AS))
    NewPtr = IC.Builder.CreateBitCast(Ptr, NewTy->getPointerTo(AS));

  LoadInst *NewLoad = IC.Builder.CreateAlignedLoad(
      NewPtr, LI.getAlignment(), LI.isVolatile(), LI.getName() + Suffix);
  NewLoad->setAtomic(LI.getOrdering(), LI.getSyncScopeID());
  MDBuilder MDB(NewLoad->getContext());
  for (const auto &MDPair : MD) {
    unsigned ID = MDPair.first;
    MDNode *N = MDPair.second;
    // Note, essentially every kind of metadata should be preserved here! This
    // routine is supposed to clone a load instruction changing *only its type*.
    // The only metadata it makes sense to drop is metadata which is invalidated
    // when the pointer type changes. This should essentially never be the case
    // in LLVM, but we explicitly switch over only known metadata to be
    // conservatively correct. If you are adding metadata to LLVM which pertains
    // to loads, you almost certainly want to add it here.
    switch (ID) {
    case LLVMContext::MD_dbg:
    case LLVMContext::MD_tbaa:
    case LLVMContext::MD_prof:
    case LLVMContext::MD_fpmath:
    case LLVMContext::MD_tbaa_struct:
    case LLVMContext::MD_invariant_load:
    case LLVMContext::MD_alias_scope:
    case LLVMContext::MD_noalias:
    case LLVMContext::MD_nontemporal:
    case LLVMContext::MD_mem_parallel_loop_access:
      // All of these directly apply.
      NewLoad->setMetadata(ID, N);
      break;

    case LLVMContext::MD_nonnull:
      copyNonnullMetadata(LI, N, *NewLoad);
      break;
    case LLVMContext::MD_align:
    case LLVMContext::MD_dereferenceable:
    case LLVMContext::MD_dereferenceable_or_null:
      // These only directly apply if the new type is also a pointer.
      if (NewTy->isPointerTy())
        NewLoad->setMetadata(ID, N);
      break;
    case LLVMContext::MD_range:
      copyRangeMetadata(IC.getDataLayout(), LI, N, *NewLoad);
      break;
    }
  }
  return NewLoad;
}

/// Combine a store to a new type.
///
/// Returns the newly created store instruction.
static StoreInst *combineStoreToNewValue(InstCombiner &IC, StoreInst &SI, Value *V) {
  assert((!SI.isAtomic() || isSupportedAtomicType(V->getType())) &&
         ""can't fold an atomic store of requested type"");

  Value *Ptr = SI.getPointerOperand();
  unsigned AS = SI.getPointerAddressSpace();
  SmallVector<std::pair<unsigned, MDNode *>, 8> MD;
  SI.getAllMetadata(MD);

  StoreInst *NewStore = IC.Builder.CreateAlignedStore(
      V, IC.Builder.CreateBitCast(Ptr, V->getType()->getPointerTo(AS)),
      SI.getAlignment(), SI.isVolatile());
  NewStore->setAtomic(SI.getOrdering(), SI.getSyncScopeID());
  for (const auto &MDPair : MD) {
    unsigned ID = MDPair.first;
    MDNode *N = MDPair.second;
    // Note, essentially every kind of metadata should be preserved here! This
    // routine is supposed to clone a store instruction changing *only its
    // type*. The only metadata it makes sense to drop is metadata which is
    // invalidated when the pointer type changes. This should essentially
    // never be the case in LLVM, but we explicitly switch over only known
    // metadata to be conservatively correct. If you are adding metadata to
    // LLVM which pertains to stores, you almost certainly want to add it
    // here.
    switch (ID) {
    case LLVMContext::MD_dbg:
    case LLVMContext::MD_tbaa:
    case LLVMContext::MD_prof:
    case LLVMContext::MD_fpmath:
    case LLVMContext::MD_tbaa_struct:
    case LLVMContext::MD_alias_scope:
    case LLVMContext::MD_noalias:
    case LLVMContext::MD_nontemporal:
    case LLVMContext::MD_mem_parallel_loop_access:
      // All of these directly apply.
      NewStore->setMetadata(ID, N);
      break;

    case LLVMContext::MD_invariant_load:
    case LLVMContext::MD_nonnull:
    case LLVMContext::MD_range:
    case LLVMContext::MD_align:
    case LLVMContext::MD_dereferenceable:
    case LLVMContext::MD_dereferenceable_or_null:
      // These don't apply for stores.
      break;
    }
  }

  return NewStore;
}

/// Returns true if instruction represent minmax pattern like:
///   select ((cmp load V1, load V2), V1, V2).
static bool isMinMaxWithLoads(Value *V) {
  assert(V->getType()->isPointerTy() && ""Expected pointer type."");
  // Ignore possible ty* to ixx* bitcast.
  V = peekThroughBitcast(V);
  // Check that select is select ((cmp load V1, load V2), V1, V2) - minmax
  // pattern.
  CmpInst::Predicate Pred;
  Instruction *L1;
  Instruction *L2;
  Value *LHS;
  Value *RHS;
  if (!match(V, m_Select(m_Cmp(Pred, m_Instruction(L1), m_Instruction(L2)),
                         m_Value(LHS), m_Value(RHS))))
    return false;
  return (match(L1, m_Load(m_Specific(LHS))) &&
          match(L2, m_Load(m_Specific(RHS)))) ||
         (match(L1, m_Load(m_Specific(RHS))) &&
          match(L2, m_Load(m_Specific(LHS))));
}

/// Combine loads to match the type of their uses' value after looking
/// through intervening bitcasts.
///
/// The core idea here is that if the result of a load is used in an operation,
/// we should load the type most conducive to that operation. For example, when
/// loading an integer and converting that immediately to a pointer, we should
/// instead directly load a pointer.
///
/// However, this routine must never change the width of a load or the number of
/// loads as that would introduce a semantic change. This combine is expected to
/// be a semantic no-op which just allows loads to more closely model the types
/// of their consuming operations.
///
/// Currently, we also refuse to change the precise type used for an atomic load
/// or a volatile load. This is debatable, and might be reasonable to change
/// later. However, it is risky in case some backend or other part of LLVM is
/// relying on the exact type loaded to select appropriate atomic operations.
static Instruction *combineLoadToOperationType(InstCombiner &IC, LoadInst &LI) {
  // FIXME: We could probably with some care handle both volatile and ordered
  // atomic loads here but it isn't clear that this is important.
  if (!LI.isUnordered())
    return nullptr;

  if (LI.use_empty())
    return nullptr;

  // swifterror values can't be bitcasted.
  if (LI.getPointerOperand()->isSwiftError())
    return nullptr;

  Type *Ty = LI.getType();
  const DataLayout &DL = IC.getDataLayout();

  // Try to canonicalize loads which are only ever stored to operate over
  // integers instead of any other type. We only do this when the loaded type
  // is sized and has a size exactly the same as its store size and the store
  // size is a legal integer type.
  // Do not perform canonicalization if minmax pattern is found (to avoid
  // infinite loop).
  if (!Ty->isIntegerTy() && Ty->isSized() &&
      DL.isLegalInteger(DL.getTypeStoreSizeInBits(Ty)) &&
      DL.getTypeStoreSizeInBits(Ty) == DL.getTypeSizeInBits(Ty) &&
      !DL.isNonIntegralPointerType(Ty) &&
      !isMinMaxWithLoads(
          peekThroughBitcast(LI.getPointerOperand(), /*OneUseOnly=*/true))) {
    if (all_of(LI.users(), [&LI](User *U) {
          auto *SI = dyn_cast<StoreInst>(U);
          return SI && SI->getPointerOperand() != &LI &&
                 !SI->getPointerOperand()->isSwiftError();
        })) {
      LoadInst *NewLoad = combineLoadToNewType(
          IC, LI,
          Type::getIntNTy(LI.getContext(), DL.getTypeStoreSizeInBits(Ty)));
      // Replace all the stores with stores of the newly loaded value.
      for (auto UI = LI.user_begin(), UE = LI.user_end(); UI != UE;) {
        auto *SI = cast<StoreInst>(*UI++);
        IC.Builder.SetInsertPoint(SI);
        combineStoreToNewValue(IC, *SI, NewLoad);
        IC.eraseInstFromFunction(*SI);
      }
      assert(LI.use_empty() && ""Failed to remove all users of the load!"");
      // Return the old load so the combiner can delete it safely.
      return &LI;
    }
  }

  // Fold away bit casts of the loaded value by loading the desired type.
  // We can do this for BitCastInsts as well as casts from and to pointer types,
  // as long as those are noops (i.e., the source or dest type have the same
  // bitwidth as the target's pointers).
  if (LI.hasOneUse())
    if (auto* CI = dyn_cast<CastInst>(LI.user_back()))
      if (CI->isNoopCast(DL))
        if (!LI.isAtomic() || isSupportedAtomicType(CI->getDestTy())) {
          LoadInst *NewLoad = combineLoadToNewType(IC, LI, CI->getDestTy());
          CI->replaceAllUsesWith(NewLoad);
          IC.eraseInstFromFunction(*CI);
          return &LI;
        }

  // FIXME: We should also canonicalize loads of vectors when their elements are
  // cast to other types.
  return nullptr;
}

static Instruction *unpackLoadToAggregate(InstCombiner &IC, LoadInst &LI) {
  // FIXME: We could probably with some care handle both volatile and atomic
  // stores here but it isn't clear that this is important.
  if (!LI.isSimple())
    return nullptr;

  Type *T = LI.getType();
  if (!T->isAggregateType())
    return nullptr;

  StringRef Name = LI.getName();
  assert(LI.getAlignment() && ""Alignment must be set at this point"");

  if (auto *ST = dyn_cast<StructType>(T)) {
    // If the struct only have one element, we unpack.
    auto NumElements = ST->getNumElements();
    if (NumElements == 1) {
      LoadInst *NewLoad = combineLoadToNewType(IC, LI, ST->getTypeAtIndex(0U),
                                               "".unpack"");
      AAMDNodes AAMD;
      LI.getAAMetadata(AAMD);
      NewLoad->setAAMetadata(AAMD);
      return IC.replaceInstUsesWith(LI, IC.Builder.CreateInsertValue(
        UndefValue::get(T), NewLoad, 0, Name));
    }

    // We don't want to break loads with padding here as we'd loose
    // the knowledge that padding exists for the rest of the pipeline.
    const DataLayout &DL = IC.getDataLayout();
    auto *SL = DL.getStructLayout(ST);
    if (SL->hasPadding())
      return nullptr;

    auto Align = LI.getAlignment();
    if (!Align)
      Align = DL.getABITypeAlignment(ST);

    auto *Addr = LI.getPointerOperand();
    auto *IdxType = Type::getInt32Ty(T->getContext());
    auto *Zero = ConstantInt::get(IdxType, 0);

    Value *V = UndefValue::get(T);
    for (unsigned i = 0; i < NumElements; i++) {
      Value *Indices[2] = {
        Zero,
        ConstantInt::get(IdxType, i),
      };
      auto *Ptr = IC.Builder.CreateInBoundsGEP(ST, Addr, makeArrayRef(Indices),
                                               Name + "".elt"");
      auto EltAlign = MinAlign(Align, SL->getElementOffset(i));
      auto *L = IC.Builder.CreateAlignedLoad(Ptr, EltAlign, Name + "".unpack"");
      // Propagate AA metadata. It'll still be valid on the narrowed load.
      AAMDNodes AAMD;
      LI.getAAMetadata(AAMD);
      L->setAAMetadata(AAMD);
      V = IC.Builder.CreateInsertValue(V, L, i);
    }

    V->setName(Name);
    return IC.replaceInstUsesWith(LI, V);
  }

  if (auto *AT = dyn_cast<ArrayType>(T)) {
    auto *ET = AT->getElementType();
    auto NumElements = AT->getNumElements();
    if (NumElements == 1) {
      LoadInst *NewLoad = combineLoadToNewType(IC, LI, ET, "".unpack"");
      AAMDNodes AAMD;
      LI.getAAMetadata(AAMD);
      NewLoad->setAAMetadata(AAMD);
      return IC.replaceInstUsesWith(LI, IC.Builder.CreateInsertValue(
        UndefValue::get(T), NewLoad, 0, Name));
    }

    // Bail out if the array is too large. Ideally we would like to optimize
    // arrays of arbitrary size but this has a terrible impact on compile time.
    // The threshold here is chosen arbitrarily, maybe needs a little bit of
    // tuning.
    if (NumElements > IC.MaxArraySizeForCombine)
      return nullptr;

    const DataLayout &DL = IC.getDataLayout();
    auto EltSize = DL.getTypeAllocSize(ET);
    auto Align = LI.getAlignment();
    if (!Align)
      Align = DL.getABITypeAlignment(T);

    auto *Addr = LI.getPointerOperand();
    auto *IdxType = Type::getInt64Ty(T->getContext());
    auto *Zero = ConstantInt::get(IdxType, 0);

    Value *V = UndefValue::get(T);
    uint64_t Offset = 0;
    for (uint64_t i = 0; i < NumElements; i++) {
      Value *Indices[2] = {
        Zero,
        ConstantInt::get(IdxType, i),
      };
      auto *Ptr = IC.Builder.CreateInBoundsGEP(AT, Addr, makeArrayRef(Indices),
                                               Name + "".elt"");
      auto *L = IC.Builder.CreateAlignedLoad(Ptr, MinAlign(Align, Offset),
                                             Name + "".unpack"");
      AAMDNodes AAMD;
      LI.getAAMetadata(AAMD);
      L->setAAMetadata(AAMD);
      V = IC.Builder.CreateInsertValue(V, L, i);
      Offset += EltSize;
    }

    V->setName(Name);
    return IC.replaceInstUsesWith(LI, V);
  }

  return nullptr;
}

// If we can determine that all possible objects pointed to by the provided
// pointer value are, not only dereferenceable, but also definitively less than
// or equal to the provided maximum size, then return true. Otherwise, return
// false (constant global values and allocas fall into this category).
//
// FIXME: This should probably live in ValueTracking (or similar).
static bool isObjectSizeLessThanOrEq(Value *V, uint64_t MaxSize,
                                     const DataLayout &DL) {
  SmallPtrSet<Value *, 4> Visited;
  SmallVector<Value *, 4> Worklist(1, V);

  do {
    Value *P = Worklist.pop_back_val();
    P = P->stripPointerCasts();

    if (!Visited.insert(P).second)
      continue;

    if (SelectInst *SI = dyn_cast<SelectInst>(P)) {
      Worklist.push_back(SI->getTrueValue());
      Worklist.push_back(SI->getFalseValue());
      continue;
    }

    if (PHINode *PN = dyn_cast<PHINode>(P)) {
      for (Value *IncValue : PN->incoming_values())
        Worklist.push_back(IncValue);
      continue;
    }

    if (GlobalAlias *GA = dyn_cast<GlobalAlias>(P)) {
      if (GA->isInterposable())
        return false;
      Worklist.push_back(GA->getAliasee());
      continue;
    }

    // If we know how big this object is, and it is less than MaxSize, continue
    // searching. Otherwise, return false.
    if (AllocaInst *AI = dyn_cast<AllocaInst>(P)) {
      if (!AI->getAllocatedType()->isSized())
        return false;

      ConstantInt *CS = dyn_cast<ConstantInt>(AI->getArraySize());
      if (!CS)
        return false;

      uint64_t TypeSize = DL.getTypeAllocSize(AI->getAllocatedType());
      // Make sure that, even if the multiplication below would wrap as an
      // uint64_t, we still do the right thing.
      if ((CS->getValue().zextOrSelf(128)*APInt(128, TypeSize)).ugt(MaxSize))
        return false;
      continue;
    }

    if (GlobalVariable *GV = dyn_cast<GlobalVariable>(P)) {
      if (!GV->hasDefinitiveInitializer() || !GV->isConstant())
        return false;

      uint64_t InitSize = DL.getTypeAllocSize(GV->getValueType());
      if (InitSize > MaxSize)
        return false;
      continue;
    }

    return false;
  } while (!Worklist.empty());

  return true;
}

// If we're indexing into an object of a known size, and the outer index is
// not a constant, but having any value but zero would lead to undefined
// behavior, replace it with zero.
//
// For example, if we have:
// @f.a = private unnamed_addr constant [1 x i32] [i32 12], align 4
// ...
// %arrayidx = getelementptr inbounds [1 x i32]* @f.a, i64 0, i64 %x
// ... = load i32* %arrayidx, align 4
// Then we know that we can replace %x in the GEP with i64 0.
//
// FIXME: We could fold any GEP index to zero that would cause UB if it were
// not zero. Currently, we only handle the first such index. Also, we could
// also search through non-zero constant indices if we kept track of the
// offsets those indices implied.
static bool canReplaceGEPIdxWithZero(InstCombiner &IC, GetElementPtrInst *GEPI,
                                     Instruction *MemI, unsigned &Idx) {
  if (GEPI->getNumOperands() < 2)
    return false;

  // Find the first non-zero index of a GEP. If all indices are zero, return
  // one past the last index.
  auto FirstNZIdx = [](const GetElementPtrInst *GEPI) {
    unsigned I = 1;
    for (unsigned IE = GEPI->getNumOperands(); I != IE; ++I) {
      Value *V = GEPI->getOperand(I);
      if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
        if (CI->isZero())
          continue;

      break;
    }

    return I;
  };

  // Skip through initial 'zero' indices, and find the corresponding pointer
  // type. See if the next index is not a constant.
  Idx = FirstNZIdx(GEPI);
  if (Idx == GEPI->getNumOperands())
    return false;
  if (isa<Constant>(GEPI->getOperand(Idx)))
    return false;

  SmallVector<Value *, 4> Ops(GEPI->idx_begin(), GEPI->idx_begin() + Idx);
  Type *AllocTy =
    GetElementPtrInst::getIndexedType(GEPI->getSourceElementType(), Ops);
  if (!AllocTy || !AllocTy->isSized())
    return false;
  const DataLayout &DL = IC.getDataLayout();
  uint64_t TyAllocSize = DL.getTypeAllocSize(AllocTy);

  // If there are more indices after the one we might replace with a zero, make
  // sure they're all non-negative. If any of them are negative, the overall
  // address being computed might be before the base address determined by the
  // first non-zero index.
  auto IsAllNonNegative = [&]() {
    for (unsigned i = Idx+1, e = GEPI->getNumOperands(); i != e; ++i) {
      KnownBits Known = IC.computeKnownBits(GEPI->getOperand(i), 0, MemI);
      if (Known.isNonNegative())
        continue;
      return false;
    }

    return true;
  };

  // FIXME: If the GEP is not inbounds, and there are extra indices after the
  // one we'll replace, those could cause the address computation to wrap
  // (rendering the IsAllNonNegative() check below insufficient). We can do
  // better, ignoring zero indices (and other indices we can prove small
  // enough not to wrap).
  if (Idx+1 != GEPI->getNumOperands() && !GEPI->isInBounds())
    return false;

  // Note that isObjectSizeLessThanOrEq will return true only if the pointer is
  // also known to be dereferenceable.
  return isObjectSizeLessThanOrEq(GEPI->getOperand(0), TyAllocSize, DL) &&
         IsAllNonNegative();
}

// If we're indexing into an object with a variable index for the memory
// access, but the object has only one element, we can assume that the index
// will always be zero. If we replace the GEP, return it.
template <typename T>
static Instruction *replaceGEPIdxWithZero(InstCombiner &IC, Value *Ptr,
                                          T &MemI) {
  if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(Ptr)) {
    unsigned Idx;
    if (canReplaceGEPIdxWithZero(IC, GEPI, &MemI, Idx)) {
      Instruction *NewGEPI = GEPI->clone();
      NewGEPI->setOperand(Idx,
        ConstantInt::get(GEPI->getOperand(Idx)->getType(), 0));
      NewGEPI->insertBefore(GEPI);
      MemI.setOperand(MemI.getPointerOperandIndex(), NewGEPI);
      return NewGEPI;
    }
  }

  return nullptr;
}

static bool canSimplifyNullStoreOrGEP(StoreInst &SI) {
  if (NullPointerIsDefined(SI.getFunction(), SI.getPointerAddressSpace()))
    return false;

  auto *Ptr = SI.getPointerOperand();
  if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(Ptr))
    Ptr = GEPI->getOperand(0);
  return (isa<ConstantPointerNull>(Ptr) &&
          !NullPointerIsDefined(SI.getFunction(), SI.getPointerAddressSpace()));
}

static bool canSimplifyNullLoadOrGEP(LoadInst &LI, Value *Op) {
  if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(Op)) {
    const Value *GEPI0 = GEPI->getOperand(0);
    if (isa<ConstantPointerNull>(GEPI0) &&
        !NullPointerIsDefined(LI.getFunction(), GEPI->getPointerAddressSpace()))
      return true;
  }
  if (isa<UndefValue>(Op) ||
      (isa<ConstantPointerNull>(Op) &&
       !NullPointerIsDefined(LI.getFunction(), LI.getPointerAddressSpace())))
    return true;
  return false;
}

Instruction *InstCombiner::visitLoadInst(LoadInst &LI) {
  Value *Op = LI.getOperand(0);

  // Try to canonicalize the loaded type.
  if (Instruction *Res = combineLoadToOperationType(*this, LI))
    return Res;

  // Attempt to improve the alignment.
  unsigned KnownAlign = getOrEnforceKnownAlignment(
      Op, DL.getPrefTypeAlignment(LI.getType()), DL, &LI, &AC, &DT);
  unsigned LoadAlign = LI.getAlignment();
  unsigned EffectiveLoadAlign =
      LoadAlign != 0 ? LoadAlign : DL.getABITypeAlignment(LI.getType());

  if (KnownAlign > EffectiveLoadAlign)
    LI.setAlignment(KnownAlign);
  else if (LoadAlign == 0)
    LI.setAlignment(EffectiveLoadAlign);

  // Replace GEP indices if possible.
  if (Instruction *NewGEPI = replaceGEPIdxWithZero(*this, Op, LI)) {
      Worklist.Add(NewGEPI);
      return &LI;
  }

  if (Instruction *Res = unpackLoadToAggregate(*this, LI))
    return Res;

  // Do really simple store-to-load forwarding and load CSE, to catch cases
  // where there are several consecutive memory accesses to the same location,
  // separated by a few arithmetic operations.
  BasicBlock::iterator BBI(LI);
  bool IsLoadCSE = false;
  if (Value *AvailableVal = FindAvailableLoadedValue(
          &LI, LI.getParent(), BBI, DefMaxInstsToScan, AA, &IsLoadCSE)) {
    if (IsLoadCSE)
      combineMetadataForCSE(cast<LoadInst>(AvailableVal), &LI);

    return replaceInstUsesWith(
        LI, Builder.CreateBitOrPointerCast(AvailableVal, LI.getType(),
                                           LI.getName() + "".cast""));
  }

  // None of the following transforms are legal for volatile/ordered atomic
  // loads.  Most of them do apply for unordered atomics.
  if (!LI.isUnordered()) return nullptr;

  // load(gep null, ...) -> unreachable
  // load null/undef -> unreachable
  // TODO: Consider a target hook for valid address spaces for this xforms.
  if (canSimplifyNullLoadOrGEP(LI, Op)) {
    // Insert a new store to null instruction before the load to indicate
    // that this code is not reachable.  We do this instead of inserting
    // an unreachable instruction directly because we cannot modify the
    // CFG.
    StoreInst *SI = new StoreInst(UndefValue::get(LI.getType()),
                                  Constant::getNullValue(Op->getType()), &LI);
    SI->setDebugLoc(LI.getDebugLoc());
    return replaceInstUsesWith(LI, UndefValue::get(LI.getType()));
  }

  if (Op->hasOneUse()) {
    // Change select and PHI nodes to select values instead of addresses: this
    // helps alias analysis out a lot, allows many others simplifications, and
    // exposes redundancy in the code.
    //
    // Note that we cannot do the transformation unless we know that the
    // introduced loads cannot trap!  Something like this is valid as long as
    // the condition is always false: load (select bool %C, int* null, int* %G),
    // but it would not be valid if we transformed it to load from null
    // unconditionally.
    //
    if (SelectInst *SI = dyn_cast<SelectInst>(Op)) {
      // load (select (Cond, &V1, &V2))  --> select(Cond, load &V1, load &V2).
      unsigned Align = LI.getAlignment();
      if (isSafeToLoadUnconditionally(SI->getOperand(1), Align, DL, SI) &&
          isSafeToLoadUnconditionally(SI->getOperand(2), Align, DL, SI)) {
        LoadInst *V1 = Builder.CreateLoad(SI->getOperand(1),
                                          SI->getOperand(1)->getName()+"".val"");
        LoadInst *V2 = Builder.CreateLoad(SI->getOperand(2),
                                          SI->getOperand(2)->getName()+"".val"");
        assert(LI.isUnordered() && ""implied by above"");
        V1->setAlignment(Align);
        V1->setAtomic(LI.getOrdering(), LI.getSyncScopeID());
        V2->setAlignment(Align);
        V2->setAtomic(LI.getOrdering(), LI.getSyncScopeID());
        return SelectInst::Create(SI->getCondition(), V1, V2);
      }

      // load (select (cond, null, P)) -> load P
      if (isa<ConstantPointerNull>(SI->getOperand(1)) &&
          !NullPointerIsDefined(SI->getFunction(),
                                LI.getPointerAddressSpace())) {
        LI.setOperand(0, SI->getOperand(2));
        return &LI;
      }

      // load (select (cond, P, null)) -> load P
      if (isa<ConstantPointerNull>(SI->getOperand(2)) &&
          !NullPointerIsDefined(SI->getFunction(),
                                LI.getPointerAddressSpace())) {
        LI.setOperand(0, SI->getOperand(1));
        return &LI;
      }
    }
  }
  return nullptr;
}

/// Look for extractelement/insertvalue sequence that acts like a bitcast.
///
/// \\returns underlying value that was ""cast"", or nullptr otherwise.
///
/// For example, if we have:
///
///     %E0 = extractelement <2 x double> %U, i32 0
///     %V0 = insertvalue [2 x double] undef, double %E0, 0
///     %E1 = extractelement <2 x double> %U, i32 1
///     %V1 = insertvalue [2 x double] %V0, double %E1, 1
///
/// and the layout of a <2 x double> is isomorphic to a [2 x double],
/// then %V1 can be safely approximated by a conceptual ""bitcast"" of %U.
/// Note that %U may contain non-undef values where %V1 has undef.
static Value *likeBitCastFromVector(InstCombiner &IC, Value *V) {
  Value *U = nullptr;
  while (auto *IV = dyn_cast<InsertValueInst>(V)) {
    auto *E = dyn_cast<ExtractElementInst>(IV->getInsertedValueOperand());
    if (!E)
      return nullptr;
    auto *W = E->getVectorOperand();
    if (!U)
      U = W;
    else if (U != W)
      return nullptr;
    auto *CI = dyn_cast<ConstantInt>(E->getIndexOperand());
    if (!CI || IV->getNumIndices() != 1 || CI->getZExtValue() != *IV->idx_begin())
      return nullptr;
    V = IV->getAggregateOperand();
  }
  if (!isa<UndefValue>(V) ||!U)
    return nullptr;

  auto *UT = cast<VectorType>(U->getType());
  auto *VT = V->getType();
  // Check that types UT and VT are bitwise isomorphic.
  const auto &DL = IC.getDataLayout();
  if (DL.getTypeStoreSizeInBits(UT) != DL.getTypeStoreSizeInBits(VT)) {
    return nullptr;
  }
  if (auto *AT = dyn_cast<ArrayType>(VT)) {
    if (AT->getNumElements() != UT->getNumElements())
      return nullptr;
  } else {
    auto *ST = cast<StructType>(VT);
    if (ST->getNumElements() != UT->getNumElements())
      return nullptr;
    for (const auto *EltT : ST->elements()) {
      if (EltT != UT->getElementType())
        return nullptr;
    }
  }
  return U;
}

/// Combine stores to match the type of value being stored.
///
/// The core idea here is that the memory does not have any intrinsic type and
/// where we can we should match the type of a store to the type of value being
/// stored.
///
/// However, this routine must never change the width of a store or the number of
/// stores as that would introduce a semantic change. This combine is expected to
/// be a semantic no-op which just allows stores to more closely model the types
/// of their incoming values.
///
/// Currently, we also refuse to change the precise type used for an atomic or
/// volatile store. This is debatable, and might be reasonable to change later.
/// However, it is risky in case some backend or other part of LLVM is relying
/// on the exact type stored to select appropriate atomic operations.
///
/// \\returns true if the store was successfully combined away. This indicates
/// the caller must erase the store instruction. We have to let the caller erase
/// the store instruction as otherwise there is no way to signal whether it was
/// combined or not: IC.EraseInstFromFunction returns a null pointer.
static bool combineStoreToValueType(InstCombiner &IC, StoreInst &SI) {
  // FIXME: We could probably with some care handle both volatile and ordered
  // atomic stores here but it isn't clear that this is important.
  if (!SI.isUnordered())
    return false;

  // swifterror values can't be bitcasted.
  if (SI.getPointerOperand()->isSwiftError())
    return false;

  Value *V = SI.getValueOperand();

  // Fold away bit casts of the stored value by storing the original type.
  if (auto *BC = dyn_cast<BitCastInst>(V)) {
    V = BC->getOperand(0);
    if (!SI.isAtomic() || isSupportedAtomicType(V->getType())) {
      combineStoreToNewValue(IC, SI, V);
      return true;
    }
  }

  if (Value *U = likeBitCastFromVector(IC, V))
    if (!SI.isAtomic() || isSupportedAtomicType(U->getType())) {
      combineStoreToNewValue(IC, SI, U);
      return true;
    }

  // FIXME: We should also canonicalize stores of vectors when their elements
  // are cast to other types.
  return false;
}

static bool unpackStoreToAggregate(InstCombiner &IC, StoreInst &SI) {
  // FIXME: We could probably with some care handle both volatile and atomic
  // stores here but it isn't clear that this is important.
  if (!SI.isSimple())
    return false;

  Value *V = SI.getValueOperand();
  Type *T = V->getType();

  if (!T->isAggregateType())
    return false;

  if (auto *ST = dyn_cast<StructType>(T)) {
    // If the struct only have one element, we unpack.
    unsigned Count = ST->getNumElements();
    if (Count == 1) {
      V = IC.Builder.CreateExtractValue(V, 0);
      combineStoreToNewValue(IC, SI, V);
      return true;
    }

    // We don't want to break loads with padding here as we'd loose
    // the knowledge that padding exists for the rest of the pipeline.
    const DataLayout &DL = IC.getDataLayout();
    auto *SL = DL.getStructLayout(ST);
    if (SL->hasPadding())
      return false;

    auto Align = SI.getAlignment();
    if (!Align)
      Align = DL.getABITypeAlignment(ST);

    SmallString<16> EltName = V->getName();
    EltName += "".elt"";
    auto *Addr = SI.getPointerOperand();
    SmallString<16> AddrName = Addr->getName();
    AddrName += "".repack"";

    auto *IdxType = Type::getInt32Ty(ST->getContext());
    auto *Zero = ConstantInt::get(IdxType, 0);
    for (unsigned i = 0; i < Count; i++) {
      Value *Indices[2] = {
        Zero,
        ConstantInt::get(IdxType, i),
      };
      auto *Ptr = IC.Builder.CreateInBoundsGEP(ST, Addr, makeArrayRef(Indices),
                                               AddrName);
      auto *Val = IC.Builder.CreateExtractValue(V, i, EltName);
      auto EltAlign = MinAlign(Align, SL->getElementOffset(i));
      llvm::Instruction *NS = IC.Builder.CreateAlignedStore(Val, Ptr, EltAlign);
      AAMDNodes AAMD;
      SI.getAAMetadata(AAMD);
      NS->setAAMetadata(AAMD);
    }

    return true;
  }

  if (auto *AT = dyn_cast<ArrayType>(T)) {
    // If the array only have one element, we unpack.
    auto NumElements = AT->getNumElements();
    if (NumElements == 1) {
      V = IC.Builder.CreateExtractValue(V, 0);
      combineStoreToNewValue(IC, SI, V);
      return true;
    }

    // Bail out if the array is too large. Ideally we would like to optimize
    // arrays of arbitrary size but this has a terrible impact on compile time.
    // The threshold here is chosen arbitrarily, maybe needs a little bit of
    // tuning.
    if (NumElements > IC.MaxArraySizeForCombine)
      return false;

    const DataLayout &DL = IC.getDataLayout();
    auto EltSize = DL.getTypeAllocSize(AT->getElementType());
    auto Align = SI.getAlignment();
    if (!Align)
      Align = DL.getABITypeAlignment(T);

    SmallString<16> EltName = V->getName();
    EltName += "".elt"";
    auto *Addr = SI.getPointerOperand();
    SmallString<16> AddrName = Addr->getName();
    AddrName += "".repack"";

    auto *IdxType = Type::getInt64Ty(T->getContext());
    auto *Zero = ConstantInt::get(IdxType, 0);

    uint64_t Offset = 0;
    for (uint64_t i = 0; i < NumElements; i++) {
      Value *Indices[2] = {
        Zero,
        ConstantInt::get(IdxType, i),
      };
      auto *Ptr = IC.Builder.CreateInBoundsGEP(AT, Addr, makeArrayRef(Indices),
                                               AddrName);
      auto *Val = IC.Builder.CreateExtractValue(V, i, EltName);
      auto EltAlign = MinAlign(Align, Offset);
      Instruction *NS = IC.Builder.CreateAlignedStore(Val, Ptr, EltAlign);
      AAMDNodes AAMD;
      SI.getAAMetadata(AAMD);
      NS->setAAMetadata(AAMD);
      Offset += EltSize;
    }

    return true;
  }

  return false;
}

/// equivalentAddressValues - Test if A and B will obviously have the same
/// value. This includes recognizing that %t0 and %t1 will have the same
/// value in code like this:
///   %t0 = getelementptr \\@a, 0, 3
///   store i32 0, i32* %t0
///   %t1 = getelementptr \\@a, 0, 3
///   %t2 = load i32* %t1
///
static bool equivalentAddressValues(Value *A, Value *B) {
  // Test if the values are trivially equivalent.
  if (A == B) return true;

  // Test if the values come form identical arithmetic instructions.
  // This uses isIdenticalToWhenDefined instead of isIdenticalTo because
  // its only used to compare two uses within the same basic block, which
  // means that they'll always either have the same value or one of them
  // will have an undefined value.
  if (isa<BinaryOperator>(A) ||
      isa<CastInst>(A) ||
      isa<PHINode>(A) ||
      isa<GetElementPtrInst>(A))
    if (Instruction *BI = dyn_cast<Instruction>(B))
      if (cast<Instruction>(A)->isIdenticalToWhenDefined(BI))
        return true;

  // Otherwise they may not be equivalent.
  return false;
}

/// Converts store (bitcast (load (bitcast (select ...)))) to
/// store (load (select ...)), where select is minmax:
/// select ((cmp load V1, load V2), V1, V2).
static bool removeBitcastsFromLoadStoreOnMinMax(InstCombiner &IC,
                                                StoreInst &SI) {
  // bitcast?
  if (!match(SI.getPointerOperand(), m_BitCast(m_Value())))
    return false;
  // load? integer?
  Value *LoadAddr;
  if (!match(SI.getValueOperand(), m_Load(m_BitCast(m_Value(LoadAddr)))))
    return false;
  auto *LI = cast<LoadInst>(SI.getValueOperand());
  if (!LI->getType()->isIntegerTy())
    return false;
  if (!isMinMaxWithLoads(LoadAddr))
    return false;

  if (!all_of(LI->users(), [LI, LoadAddr](User *U) {
        auto *SI = dyn_cast<StoreInst>(U);
        return SI && SI->getPointerOperand() != LI &&
               peekThroughBitcast(SI->getPointerOperand()) != LoadAddr &&
               !SI->getPointerOperand()->isSwiftError();
      }))
    return false;

  IC.Builder.SetInsertPoint(LI);
  LoadInst *NewLI = combineLoadToNewType(
      IC, *LI, LoadAddr->getType()->getPointerElementType());
  // Replace all the stores with stores of the newly loaded value.
  for (auto *UI : LI->users()) {
    auto *USI = cast<StoreInst>(UI);
    IC.Builder.SetInsertPoint(USI);
    combineStoreToNewValue(IC, *USI, NewLI);
  }
  IC.replaceInstUsesWith(*LI, UndefValue::get(LI->getType()));
  IC.eraseInstFromFunction(*LI);
  return true;
}

Instruction *InstCombiner::visitStoreInst(StoreInst &SI) {
  Value *Val = SI.getOperand(0);
  Value *Ptr = SI.getOperand(1);

  // Try to canonicalize the stored type.
  if (combineStoreToValueType(*this, SI))
    return eraseInstFromFunction(SI);

  // Attempt to improve the alignment.
  unsigned KnownAlign = getOrEnforceKnownAlignment(
      Ptr, DL.getPrefTypeAlignment(Val->getType()), DL, &SI, &AC, &DT);
  unsigned StoreAlign = SI.getAlignment();
  unsigned EffectiveStoreAlign =
      StoreAlign != 0 ? StoreAlign : DL.getABITypeAlignment(Val->getType());

  if (KnownAlign > EffectiveStoreAlign)
    SI.setAlignment(KnownAlign);
  else if (StoreAlign == 0)
    SI.setAlignment(EffectiveStoreAlign);

  // Try to canonicalize the stored type.
  if (unpackStoreToAggregate(*this, SI))
    return eraseInstFromFunction(SI);

  if (removeBitcastsFromLoadStoreOnMinMax(*this, SI))
    return eraseInstFromFunction(SI);

  // Replace GEP indices if possible.
  if (Instruction *NewGEPI = replaceGEPIdxWithZero(*this, Ptr, SI)) {
      Worklist.Add(NewGEPI);
      return &SI;
  }

  // Don't hack volatile/ordered stores.
  // FIXME: Some bits are legal for ordered atomic stores; needs refactoring.
  if (!SI.isUnordered()) return nullptr;

  // If the RHS is an alloca with a single use, zapify the store, making the
  // alloca dead.
  if (Ptr->hasOneUse()) {
    if (isa<AllocaInst>(Ptr))
      return eraseInstFromFunction(SI);
    if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Ptr)) {
      if (isa<AllocaInst>(GEP->getOperand(0))) {
        if (GEP->getOperand(0)->hasOneUse())
          return eraseInstFromFunction(SI);
      }
    }
  }

  // Do really simple DSE, to catch cases where there are several consecutive
  // stores to the same location, separated by a few arithmetic operations. This
  // situation often occurs with bitfield accesses.
  BasicBlock::iterator BBI(SI);
  for (unsigned ScanInsts = 6; BBI != SI.getParent()->begin() && ScanInsts;
       --ScanInsts) {
    --BBI;
    // Don't count debug info directives, lest they affect codegen,
    // and we skip pointer-to-pointer bitcasts, which are NOPs.
    if (isa<DbgInfoIntrinsic>(BBI) ||
        (isa<BitCastInst>(BBI) && BBI->getType()->isPointerTy())) {
      ScanInsts++;
      continue;
    }

    if (StoreInst *PrevSI = dyn_cast<StoreInst>(BBI)) {
      // Prev store isn't volatile, and stores to the same location?
      if (PrevSI->isUnordered() && equivalentAddressValues(PrevSI->getOperand(1),
                                                        SI.getOperand(1))) {
        ++NumDeadStore;
        ++BBI;
        eraseInstFromFunction(*PrevSI);
        continue;
      }
      break;
    }

    // If this is a load, we have to stop.  However, if the loaded value is from
    // the pointer we're loading and is producing the pointer we're storing,
    // then *this* store is dead (X = load P; store X -> P).
    if (LoadInst *LI = dyn_cast<LoadInst>(BBI)) {
      if (LI == Val && equivalentAddressValues(LI->getOperand(0), Ptr)) {
        assert(SI.isUnordered() && ""can't eliminate ordering operation"");
        return eraseInstFromFunction(SI);
      }

      // Otherwise, this is a load from some other location.  Stores before it
      // may not be dead.
      break;
    }

    // Don't skip over loads, throws or things that can modify memory.
    if (BBI->mayWriteToMemory() || BBI->mayReadFromMemory() || BBI->mayThrow())
      break;
  }

  // store X, null    -> turns into 'unreachable' in SimplifyCFG
  // store X, GEP(null, Y) -> turns into 'unreachable' in SimplifyCFG
  if (canSimplifyNullStoreOrGEP(SI)) {
    if (!isa<UndefValue>(Val)) {
      SI.setOperand(0, UndefValue::get(Val->getType()));
      if (Instruction *U = dyn_cast<Instruction>(Val))
        Worklist.Add(U);  // Dropped a use.
    }
    return nullptr;  // Do not modify these!
  }

  // store undef, Ptr -> noop
  if (isa<UndefValue>(Val))
    return eraseInstFromFunction(SI);

  // If this store is the last instruction in the basic block (possibly
  // excepting debug info instructions), and if the block ends with an
  // unconditional branch, try to move it to the successor block.
  BBI = SI.getIterator();
  do {
    ++BBI;
  } while (isa<DbgInfoIntrinsic>(BBI) ||
           (isa<BitCastInst>(BBI) && BBI->getType()->isPointerTy()));
  if (BranchInst *BI = dyn_cast<BranchInst>(BBI))
    if (BI->isUnconditional())
      if (SimplifyStoreAtEndOfBlock(SI))
        return nullptr;  // xform done!

  return nullptr;
}

/// SimplifyStoreAtEndOfBlock - Turn things like:
///   if () { *P = v1; } else { *P = v2 }
/// into a phi node with a store in the successor.
///
/// Simplify things like:
///   *P = v1; if () { *P = v2; }
/// into a phi node with a store in the successor.
///
bool InstCombiner::SimplifyStoreAtEndOfBlock(StoreInst &SI) {
  assert(SI.isUnordered() &&
         ""this code has not been auditted for volatile or ordered store case"");

  BasicBlock *StoreBB = SI.getParent();

  // Check to see if the successor block has exactly two incoming edges.  If
  // so, see if the other predecessor contains a store to the same location.
  // if so, insert a PHI node (if needed) and move the stores down.
  BasicBlock *DestBB = StoreBB->getTerminator()->getSuccessor(0);

  // Determine whether Dest has exactly two predecessors and, if so, compute
  // the other predecessor.
  pred_iterator PI = pred_begin(DestBB);
  BasicBlock *P = *PI;
  BasicBlock *OtherBB = nullptr;

  if (P != StoreBB)
    OtherBB = P;

  if (++PI == pred_end(DestBB))
    return false;

  P = *PI;
  if (P != StoreBB) {
    if (OtherBB)
      return false;
    OtherBB = P;
  }
  if (++PI != pred_end(DestBB))
    return false;

  // Bail out if all the relevant blocks aren't distinct (this can happen,
  // for example, if SI is in an infinite loop)
  if (StoreBB == DestBB || OtherBB == DestBB)
    return false;

  // Verify that the other block ends in a branch and is not otherwise empty.
  BasicBlock::iterator BBI(OtherBB->getTerminator());
  BranchInst *OtherBr = dyn_cast<BranchInst>(BBI);
  if (!OtherBr || BBI == OtherBB->begin())
    return false;

  // If the other block ends in an unconditional branch, check for the 'if then
  // else' case.  there is an instruction before the branch.
  StoreInst *OtherStore = nullptr;
  if (OtherBr->isUnconditional()) {
    --BBI;
    // Skip over debugging info.
    while (isa<DbgInfoIntrinsic>(BBI) ||
           (isa<BitCastInst>(BBI) && BBI->getType()->isPointerTy())) {
      if (BBI==OtherBB->begin())
        return false;
      --BBI;
    }
    // If this isn't a store, isn't a store to the same location, or is not the
    // right kind of store, bail out.
    OtherStore = dyn_cast<StoreInst>(BBI);
    if (!OtherStore || OtherStore->getOperand(1) != SI.getOperand(1) ||
        !SI.isSameOperationAs(OtherStore))
      return false;
  } else {
    // Otherwise, the other block ended with a conditional branch. If one of the
    // destinations is StoreBB, then we have the if/then case.
    if (OtherBr->getSuccessor(0) != StoreBB &&
        OtherBr->getSuccessor(1) != StoreBB)
      return false;

    // Okay, we know that OtherBr now goes to Dest and StoreBB, so this is an
    // if/then triangle.  See if there is a store to the same ptr as SI that
    // lives in OtherBB.
    for (;; --BBI) {
      // Check to see if we find the matching store.
      if ((OtherStore = dyn_cast<StoreInst>(BBI))) {
        if (OtherStore->getOperand(1) != SI.getOperand(1) ||
            !SI.isSameOperationAs(OtherStore))
          return false;
        break;
      }
      // If we find something that may be using or overwriting the stored
      // value, or if we run out of instructions, we can't do the xform.
      if (BBI->mayReadFromMemory() || BBI->mayThrow() ||
          BBI->mayWriteToMemory() || BBI == OtherBB->begin())
        return false;
    }

    // In order to eliminate the store in OtherBr, we have to
    // make sure nothing reads or overwrites the stored value in
    // StoreBB.
    for (BasicBlock::iterator I = StoreBB->begin(); &*I != &SI; ++I) {
      // FIXME: This should really be AA driven.
      if (I->mayReadFromMemory() || I->mayThrow() || I->mayWriteToMemory())
        return false;
    }
  }

  // Insert a PHI node now if we need it.
  Value *MergedVal = OtherStore->getOperand(0);
  if (MergedVal != SI.getOperand(0)) {
    PHINode *PN = PHINode::Create(MergedVal->getType(), 2, ""storemerge"");
    PN->addIncoming(SI.getOperand(0), SI.getParent());
    PN->addIncoming(OtherStore->getOperand(0), OtherBB);
    MergedVal = InsertNewInstBefore(PN, DestBB->front());
  }

  // Advance to a place where it is safe to insert the new store and
  // insert it.
  BBI = DestBB->getFirstInsertionPt();
  StoreInst *NewSI = new StoreInst(MergedVal, SI.getOperand(1),
                                   SI.isVolatile(),
                                   SI.getAlignment(),
                                   SI.getOrdering(),
                                   SI.getSyncScopeID());
  InsertNewInstBefore(NewSI, *BBI);
  // The debug locations of the original instructions might differ; merge them.
  NewSI->applyMergedLocation(SI.getDebugLoc(), OtherStore->getDebugLoc());

  // If the two stores had AA tags, merge them.
  AAMDNodes AATags;
  SI.getAAMetadata(AATags);
  if (AATags) {
    OtherStore->getAAMetadata(AATags, /* Merge = */ true);
    NewSI->setAAMetadata(AATags);
  }

  // Nuke the old stores.
  eraseInstFromFunction(SI);
  eraseInstFromFunction(*OtherStore);
  return true;
}
",16269,True,3062.0246693436065,median
"*&---------------------------------------------------------------------*
*& Local class definition - Planned Events Fillers
*&---------------------------------------------------------------------*
**********************************************************************
*** Statuses of Inbound Delivery Item ********************************
**********************************************************************
CLASS lcl_dl_event_relevance DEFINITION.
  PUBLIC SECTION.
    METHODS constructor
      IMPORTING
        io_ef_parameters TYPE REF TO lif_ef_parameters
        is_app_objects   TYPE trxas_appobj_ctab_wa OPTIONAL.

    METHODS initiate
      RAISING
        cx_udm_message.

    METHODS is_enabled
      IMPORTING
        iv_milestone     TYPE clike
      RETURNING
        VALUE(rv_result) TYPE abap_bool
      RAISING
        cx_udm_message.

    METHODS update.

  PRIVATE SECTION.
    DATA: mo_ef_parameters TYPE REF TO lif_ef_parameters,
          ms_app_objects   TYPE trxas_appobj_ctab_wa,
          ms_relevance     TYPE zpof_gtt_ee_rel.

    METHODS get_field_name
      IMPORTING
        iv_milestone         TYPE clike
        iv_internal          TYPE abap_bool DEFAULT abap_false
      RETURNING
        VALUE(rv_field_name) TYPE fieldname
      RAISING
        cx_udm_message.

    METHODS get_item_status
      IMPORTING
        iv_milestone    TYPE clike
      RETURNING
        VALUE(rv_value) TYPE /saptrx/paramval200
      RAISING
        cx_udm_message.

    METHODS set_relevance
      IMPORTING
        iv_milestone TYPE clike
        iv_relevance TYPE clike
      RAISING
        cx_udm_message.

    METHODS recalc_relevance
      IMPORTING
        iv_milestone TYPE clike
      RAISING
        cx_udm_message.
ENDCLASS.

CLASS lcl_dl_event_relevance IMPLEMENTATION.
  METHOD constructor.
    mo_ef_parameters  = io_ef_parameters.
    ms_app_objects    = is_app_objects.
  ENDMETHOD.

  METHOD get_field_name.
    CASE iv_milestone.
      WHEN lif_pof_constants=>cs_milestone-dl_put_away.
        rv_field_name   = 'KOSTA'.
      WHEN lif_pof_constants=>cs_milestone-dl_packing.
        rv_field_name   = 'PKSTA'.
      WHEN lif_pof_constants=>cs_milestone-dl_goods_receipt.
        rv_field_name   = 'WBSTA'.
      WHEN lif_pof_constants=>cs_milestone-dl_pod.
        rv_field_name   = COND #( WHEN iv_internal = abap_true
                                    THEN 'PDSTK'
                                    ELSE 'PDSTA' ).
      WHEN OTHERS.
        MESSAGE e009(zpof_gtt) WITH iv_milestone INTO DATA(lv_dummy).
        lcl_tools=>throw_exception( ).
    ENDCASE.

    IF iv_internal = abap_true.
      rv_field_name   = |Z_{ rv_field_name }|.
    ENDIF.
  ENDMETHOD.

  METHOD get_item_status.
    TYPES: tt_vbup  TYPE STANDARD TABLE OF vbupvb.

    DATA: lv_dummy  TYPE char100.

    FIELD-SYMBOLS: <lt_vbup>  TYPE tt_vbup,
                   <ls_vbup>  TYPE vbupvb,
                   <lv_value> TYPE any.

    DATA(lv_fname)  = get_field_name( iv_milestone = iv_milestone ).

    DATA(lv_vbeln)  = lcl_tools=>get_field_of_structure(
                        ir_struct_data = ms_app_objects-maintabref
                        iv_field_name  = 'VBELN' ).

    DATA(lv_posnr)  = lcl_tools=>get_field_of_structure(
                        ir_struct_data = ms_app_objects-maintabref
                        iv_field_name  = 'POSNR' ).

    DATA(lr_vbup)   = mo_ef_parameters->get_appl_table(
                        iv_tabledef    = lif_pof_constants=>cs_tabledef-dl_itm_status_new ).

    CLEAR rv_value.

    ASSIGN lr_vbup->* TO <lt_vbup>.

    IF <lt_vbup> IS ASSIGNED.
      READ TABLE <lt_vbup> ASSIGNING <ls_vbup>
        WITH KEY vbeln  = lv_vbeln
                 posnr  = lv_posnr.

      IF sy-subrc = 0.
        ASSIGN COMPONENT lv_fname OF STRUCTURE <ls_vbup> TO <lv_value>.
        IF <lv_value> IS ASSIGNED.
          rv_value  = <lv_value>.
        ELSE.
          MESSAGE e001(zpof_gtt) WITH lv_fname 'VBUP' INTO lv_dummy.
          lcl_tools=>throw_exception( ).
        ENDIF.
      ELSE.
        MESSAGE e005(zpof_gtt)
          WITH 'VBUP' |{ lv_vbeln }-{ lv_posnr }|
          INTO lv_dummy.
        lcl_tools=>throw_exception( ).
      ENDIF.
    ELSE.
      MESSAGE e002(zpof_gtt) WITH 'VBUP' INTO lv_dummy.
      lcl_tools=>throw_exception( ).
    ENDIF.
  ENDMETHOD.

  METHOD initiate.
    DATA(lv_appobjid) = lcl_dl_tools=>get_tracking_id_dl_item(
                          ir_lips = ms_app_objects-maintabref ).

    "" read stored statuses
    SELECT SINGLE *
      INTO @ms_relevance
      FROM zpof_gtt_ee_rel
      WHERE appobjid  = @lv_appobjid.

    "" initiate statuses with initial values
    IF sy-subrc <> 0.
      CLEAR: ms_relevance.
      ms_relevance-appobjid = lv_appobjid.

      "" recalculate statuses
      recalc_relevance( iv_milestone = lif_pof_constants=>cs_milestone-dl_put_away ).
      recalc_relevance( iv_milestone = lif_pof_constants=>cs_milestone-dl_packing ).
      recalc_relevance( iv_milestone = lif_pof_constants=>cs_milestone-dl_goods_receipt ).
      recalc_relevance( iv_milestone = lif_pof_constants=>cs_milestone-dl_pod ).
    ENDIF.
  ENDMETHOD.

  METHOD is_enabled.
    DATA(lv_field_name) = get_field_name(
                            iv_milestone   = iv_milestone
                            iv_internal = abap_true ).

    ASSIGN COMPONENT lv_field_name OF STRUCTURE ms_relevance
      TO FIELD-SYMBOL(<lv_value>).

    IF <lv_value> IS ASSIGNED.
      rv_result   = <lv_value>.
    ELSE.
      MESSAGE e001(zpof_gtt) WITH lv_field_name '' INTO DATA(lv_dummy).
      lcl_tools=>throw_exception( ).
    ENDIF.
  ENDMETHOD.

  METHOD set_relevance.
    DATA(lv_fname_int) = get_field_name(
                           iv_milestone = iv_milestone
                           iv_internal  = abap_true ).

    ASSIGN COMPONENT lv_fname_int OF STRUCTURE ms_relevance
      TO FIELD-SYMBOL(<lv_flag>).

    IF <lv_flag> IS ASSIGNED.
      <lv_flag>   = iv_relevance.
    ELSE.
      MESSAGE e001(zpof_gtt) WITH lv_fname_int '' INTO DATA(lv_dummy).
      lcl_tools=>throw_exception( ).
    ENDIF.
  ENDMETHOD.

  METHOD recalc_relevance.
    "" retrieve delivery item status field value
    DATA(lv_status)     = get_item_status( iv_milestone = iv_milestone ).

    "" calculate relevance
    ""   for shipment POD planning :
    ""     status is <> 'empty' -> relevant
    ""   for other delivery item level planned events:
    ""     initial value is 'A' -> relevant
    DATA(lv_relevance)  = COND abap_bool(
      WHEN lv_status = lif_pof_constants=>cs_delivery_stat-not_relevant
        THEN abap_false
      WHEN lv_status = lif_pof_constants=>cs_delivery_stat-not_processed OR
           iv_milestone = lif_pof_constants=>cs_milestone-dl_pod
        THEN abap_true
        ELSE abap_undefined
    ).

    "" update flag value if it has appropriate value
    IF lv_relevance <> abap_undefined.
      set_relevance(
        EXPORTING
          iv_milestone = iv_milestone
          iv_relevance = lv_relevance ).
    ENDIF.
  ENDMETHOD.

  METHOD update.
    CALL FUNCTION 'ZPOF_GTT_UPDATE_RELEVANCE_TAB'
      DESTINATION 'NONE'
      EXPORTING
        is_relevance = ms_relevance.

    CALL FUNCTION 'BAPI_TRANSACTION_COMMIT'
      DESTINATION 'NONE'.

    CALL FUNCTION 'RFC_CONNECTION_CLOSE'  ##FM_SUBRC_OK
      EXPORTING
        destination          = 'NONE'
      EXCEPTIONS
        destination_not_open = 1
        OTHERS               = 2.
  ENDMETHOD.
ENDCLASS.

**********************************************************************
*** Planned Events of Purchase Order Item ****************************
**********************************************************************
CLASS lcl_pe_filler_po_item DEFINITION.
  PUBLIC SECTION.
    INTERFACES lif_pe_filler.

    METHODS constructor
      IMPORTING
        io_ef_parameters TYPE REF TO lif_ef_parameters
        io_bo_reader     TYPE REF TO lif_bo_reader.

  PRIVATE SECTION.
    DATA: mo_ef_parameters TYPE REF TO lif_ef_parameters,
          mo_bo_reader     TYPE REF TO lif_bo_reader.

    METHODS add_confirmation_event
      IMPORTING
        is_app_objects  TYPE trxas_appobj_ctab_wa
      CHANGING
        ct_expeventdata TYPE lif_ef_types=>tt_expeventdata
      RAISING
        cx_udm_message.

    METHODS add_goods_receipt_event
      IMPORTING
        is_app_objects  TYPE trxas_appobj_ctab_wa
      CHANGING
        ct_expeventdata TYPE lif_ef_types=>tt_expeventdata
      RAISING
        cx_udm_message.

    METHODS get_delivery_datetime
      IMPORTING
        is_app_objects     TYPE trxas_appobj_ctab_wa
      RETURNING
        VALUE(rv_datetime) TYPE /saptrx/event_exp_datetime
      RAISING
        cx_udm_message.

    METHODS get_object_field_value
      IMPORTING
        is_app_objects  TYPE trxas_appobj_ctab_wa
        iv_fieldname    TYPE clike
      RETURNING
        VALUE(rv_value) TYPE char50
      RAISING
        cx_udm_message.
ENDCLASS.

CLASS lcl_pe_filler_po_item IMPLEMENTATION.
  METHOD add_confirmation_event.
    DATA: lv_kzabs    TYPE ekpo-kzabs.

    lv_kzabs    = lcl_tools=>get_field_of_structure(
                    ir_struct_data = is_app_objects-maintabref
                    iv_field_name  = 'KZABS' ).

    IF lv_kzabs IS NOT INITIAL.
      ct_expeventdata = VALUE #( BASE ct_expeventdata (
        appsys            = mo_ef_parameters->get_appsys(  )
        appobjtype        = mo_ef_parameters->get_app_obj_types( )-aotype
        language          = sy-langu
        appobjid          = is_app_objects-appobjid
        milestone         = lif_pof_constants=>cs_milestone-po_confirmation
      ) ).
    ENDIF.
  ENDMETHOD.

  METHOD add_goods_receipt_event.
    DATA: lv_wepos TYPE ekpo-wepos,
          lv_loekz TYPE ekpo-loekz.

    lv_wepos   = lcl_tools=>get_field_of_structure(
                   ir_struct_data = is_app_objects-maintabref
                   iv_field_name  = 'WEPOS' ).

    IF lv_wepos IS NOT INITIAL.
      "" clear expecting datetime and timezone when Item is marked as deleted
      "" to avoid generation of unwanted GTTOverdue events
      lv_loekz   = lcl_tools=>get_field_of_structure(
                     ir_struct_data = is_app_objects-maintabref
                     iv_field_name  = 'LOEKZ' ).

      ct_expeventdata = VALUE #( BASE ct_expeventdata (
        appsys            = mo_ef_parameters->get_appsys(  )
        appobjtype        = mo_ef_parameters->get_app_obj_types( )-aotype
        language          = sy-langu
        appobjid          = is_app_objects-appobjid
        milestone         = lif_pof_constants=>cs_milestone-po_goods_receipt
        evt_exp_tzone     = COND #( WHEN lv_loekz IS INITIAL
                                      THEN lcl_tools=>get_system_time_zone( ) )
        evt_exp_datetime  = COND #( WHEN lv_loekz IS INITIAL
                                      THEN get_delivery_datetime( is_app_objects = is_app_objects ) )
        locid1            = lcl_tools=>get_field_of_structure(
                                ir_struct_data = is_app_objects-maintabref
                                iv_field_name  = 'WERKS' )
        loctype           = lif_ef_constants=>cs_loc_types-plant
      ) ).

    ENDIF.
  ENDMETHOD.

  METHOD constructor.
    mo_ef_parameters    = io_ef_parameters.
    mo_bo_reader        = io_bo_reader.
  ENDMETHOD.

  METHOD get_delivery_datetime.
    rv_datetime = lcl_tools=>get_local_timestamp(
                    iv_date = get_object_field_value(
                                is_app_objects = is_app_objects
                                iv_fieldname   = 'EINDT' )
                    iv_time = CONV t( '000000' ) ).
  ENDMETHOD.

  METHOD get_object_field_value.
    DATA: lr_data  TYPE REF TO data,
          lv_dummy TYPE char100.

    FIELD-SYMBOLS: <ls_data>  TYPE any,
                   <lv_value> TYPE any.

    lr_data = mo_bo_reader->get_data( is_app_object = is_app_objects ).

    ASSIGN lr_data->* TO <ls_data>.
    IF <ls_data> IS ASSIGNED.
      ASSIGN COMPONENT iv_fieldname OF STRUCTURE <ls_data> TO <lv_value>.
      IF <lv_value> IS ASSIGNED.
        rv_value = <lv_value>.
      ELSE.
        MESSAGE e001(zpof_gtt) WITH iv_fieldname 'po item' INTO lv_dummy ##NO_TEXT.
        lcl_tools=>throw_exception( ).
      ENDIF.
    ELSE.
      MESSAGE e002(zpof_gtt) WITH 'po item' INTO lv_dummy ##NO_TEXT .
      lcl_tools=>throw_exception( ).
    ENDIF.
  ENDMETHOD.

  METHOD lif_pe_filler~check_relevance.
    TYPES: tt_ekpo    TYPE STANDARD TABLE OF uekpo.

    DATA: lv_dummy    TYPE char100.

    FIELD-SYMBOLS: <ls_ekpo_new> TYPE uekpo,
                   <lt_ekpo_old> TYPE tt_ekpo,
                   <ls_ekpo_old> TYPE uekpo.

    rv_result = lif_ef_constants=>cs_condition-false.

    IF lcl_po_tools=>is_appropriate_po_type( ir_ekko = is_app_objects-mastertabref ) = abap_true AND
       lcl_po_tools=>is_appropriate_po_item( ir_ekpo = is_app_objects-maintabref ) = abap_true.

      IF is_app_objects-update_indicator = lif_ef_constants=>cs_change_mode-insert.
        rv_result = lif_ef_constants=>cs_condition-true.
      ELSE.
        DATA(lr_ekpo) = mo_ef_parameters->get_appl_table(
                          iv_tabledef = lif_pof_constants=>cs_tabledef-po_item_old ).

        ASSIGN is_app_objects-maintabref->* TO <ls_ekpo_new>.
        ASSIGN lr_ekpo->* TO <lt_ekpo_old>.

        IF <ls_ekpo_new> IS ASSIGNED AND
           <lt_ekpo_old> IS ASSIGNED AND
           ( <ls_ekpo_new>-kz = lif_ef_constants=>cs_change_mode-update OR
             <ls_ekpo_new>-kz = lif_ef_constants=>cs_change_mode-undefined ).

          READ TABLE <lt_ekpo_old> ASSIGNING <ls_ekpo_old>
            WITH KEY ebeln = <ls_ekpo_new>-ebeln
                     ebelp = <ls_ekpo_new>-ebelp.
          IF sy-subrc = 0.
            rv_result = COND #( WHEN <ls_ekpo_new>-kzabs <> <ls_ekpo_old>-kzabs OR
                                     <ls_ekpo_new>-wepos <> <ls_ekpo_old>-wepos OR
                                     <ls_ekpo_new>-loekz <> <ls_ekpo_old>-loekz
                                  THEN lif_ef_constants=>cs_condition-true
                                  ELSE lif_ef_constants=>cs_condition-false ).
          ELSE.
            MESSAGE e005(zpof_gtt)
              WITH 'EKPO' |{ <ls_ekpo_new>-ebeln }{ <ls_ekpo_new>-ebelp }|
              INTO lv_dummy.
            lcl_tools=>throw_exception( ).
          ENDIF.
        ELSE.
          MESSAGE e002(zpof_gtt) WITH 'EKPO' INTO lv_dummy.
          lcl_tools=>throw_exception( ).
        ENDIF.
      ENDIF.
    ENDIF.
  ENDMETHOD.

  METHOD lif_pe_filler~get_planed_events.
    add_confirmation_event(
      EXPORTING
        is_app_objects  = is_app_objects
      CHANGING
        ct_expeventdata = ct_expeventdata ).

    add_goods_receipt_event(
      EXPORTING
        is_app_objects  = is_app_objects
      CHANGING
        ct_expeventdata = ct_expeventdata ).
  ENDMETHOD.
ENDCLASS.

**********************************************************************
*** Planned Events Inbound Delivery Item *****************************
**********************************************************************
CLASS lcl_pe_filler_dl_item DEFINITION.
  PUBLIC SECTION.
    INTERFACES lif_pe_filler.

    METHODS constructor
      IMPORTING
        io_ef_parameters TYPE REF TO lif_ef_parameters
        io_bo_reader     TYPE REF TO lif_bo_reader.

  PRIVATE SECTION.
    DATA: mo_ef_parameters TYPE REF TO lif_ef_parameters,
          mo_bo_reader     TYPE REF TO lif_bo_reader.

    METHODS add_goods_receipt_event
      IMPORTING
        is_app_objects  TYPE trxas_appobj_ctab_wa
        io_relevance    TYPE REF TO lcl_dl_event_relevance
      CHANGING
        ct_expeventdata TYPE lif_ef_types=>tt_expeventdata
      RAISING
        cx_udm_message.

    METHODS add_packing_event
      IMPORTING
        is_app_objects  TYPE trxas_appobj_ctab_wa
        io_relevance    TYPE REF TO lcl_dl_event_relevance
      CHANGING
        ct_expeventdata TYPE lif_ef_types=>tt_expeventdata
      RAISING
        cx_udm_message.

    METHODS add_put_away_event
      IMPORTING
        is_app_objects  TYPE trxas_appobj_ctab_wa
        io_relevance    TYPE REF TO lcl_dl_event_relevance
      CHANGING
        ct_expeventdata TYPE lif_ef_types=>tt_expeventdata
      RAISING
        cx_udm_message.

    METHODS get_delivery_date
      IMPORTING
        ir_data        TYPE REF TO data
      RETURNING
        VALUE(rv_date) TYPE /saptrx/event_exp_datetime
      RAISING
        cx_udm_message.

    METHODS is_time_of_delivery_changed
      IMPORTING
        is_app_objects   TYPE trxas_appobj_ctab_wa
      RETURNING
        VALUE(rv_result) TYPE abap_bool
      RAISING
        cx_udm_message.
ENDCLASS.

CLASS lcl_pe_filler_dl_item IMPLEMENTATION.
  METHOD constructor.
    mo_ef_parameters    = io_ef_parameters.
    mo_bo_reader        = io_bo_reader.
  ENDMETHOD.

  METHOD add_goods_receipt_event.
    IF io_relevance->is_enabled(
         iv_milestone   = lif_pof_constants=>cs_milestone-dl_goods_receipt ) = abap_true.

      ct_expeventdata = VALUE #( BASE ct_expeventdata (
        appsys            = mo_ef_parameters->get_appsys(  )
        appobjtype        = mo_ef_parameters->get_app_obj_types( )-aotype
        language          = sy-langu
        appobjid          = is_app_objects-appobjid
        milestone         = lif_pof_constants=>cs_milestone-dl_goods_receipt
        evt_exp_tzone     = lcl_tools=>get_system_time_zone( )
        evt_exp_datetime  = get_delivery_date(
                              ir_data = is_app_objects-mastertabref )
        locid1            = lcl_tools=>get_field_of_structure(
                              ir_struct_data = is_app_objects-maintabref
                              iv_field_name  = 'WERKS' )
        loctype           = lif_ef_constants=>cs_loc_types-plant
      ) ).
    ENDIF.
  ENDMETHOD.

  METHOD add_packing_event.
    IF io_relevance->is_enabled(
         iv_milestone   = lif_pof_constants=>cs_milestone-dl_packing ) = abap_true.

      ct_expeventdata = VALUE #( BASE ct_expeventdata (
        appsys            = mo_ef_parameters->get_appsys(  )
        appobjtype        = mo_ef_parameters->get_app_obj_types( )-aotype
        language          = sy-langu
        appobjid          = is_app_objects-appobjid
        milestone         = lif_pof_constants=>cs_milestone-dl_packing
        evt_exp_tzone     = lcl_tools=>get_system_time_zone( )
        locid1            = lcl_tools=>get_field_of_structure(
                              ir_struct_data = is_app_objects-maintabref
                              iv_field_name  = 'WERKS' )
        loctype           = lif_ef_constants=>cs_loc_types-plant
      ) ).
    ENDIF.
  ENDMETHOD.

  METHOD add_put_away_event.
    IF io_relevance->is_enabled(
         iv_milestone   = lif_pof_constants=>cs_milestone-dl_put_away ) = abap_true.
      ct_expeventdata = VALUE #( BASE ct_expeventdata (
        appsys            = mo_ef_parameters->get_appsys(  )
        appobjtype        = mo_ef_parameters->get_app_obj_types( )-aotype
        language          = sy-langu
        appobjid          = is_app_objects-appobjid
        milestone         = lif_pof_constants=>cs_milestone-dl_put_away
        evt_exp_tzone     = lcl_tools=>get_system_time_zone( )
        evt_exp_datetime  = get_delivery_date(
                              ir_data = is_app_objects-mastertabref )
        locid1            = lcl_tools=>get_field_of_structure(
                              ir_struct_data = is_app_objects-maintabref
                              iv_field_name  = 'WERKS' )
        loctype           = lif_ef_constants=>cs_loc_types-plant
      ) ).
    ENDIF.
  ENDMETHOD.

  METHOD get_delivery_date.
    rv_date = lcl_tools=>get_local_timestamp(
                iv_date = lcl_tools=>get_field_of_structure(
                            ir_struct_data = ir_data
                            iv_field_name  = 'LFDAT' )
                iv_time = lcl_tools=>get_field_of_structure(
                            ir_struct_data = ir_data
                            iv_field_name  = 'LFUHR' ) ).
  ENDMETHOD.

  METHOD is_time_of_delivery_changed.
    TYPES: tt_likp    TYPE STANDARD TABLE OF likpvb.

    DATA: lv_vbeln     TYPE likp-vbeln,
          lv_lfuhr_new TYPE lfuhr,
          lv_lfuhr_old TYPE lfuhr.

    lv_lfuhr_new  = lcl_tools=>get_field_of_structure(
                      ir_struct_data = is_app_objects-mastertabref
                      iv_field_name  = 'LFUHR' ).

    DATA(lr_likp)  = mo_ef_parameters->get_appl_table(
                       iv_tabledef = lif_pof_constants=>cs_tabledef-dl_header_old ).

    FIELD-SYMBOLS: <lt_likp> TYPE tt_likp.

    IF lr_likp IS BOUND.
      ASSIGN lr_likp->* TO <lt_likp>.

      IF <lt_likp> IS ASSIGNED.
        lv_vbeln  = lcl_tools=>get_field_of_structure(
                      ir_struct_data = is_app_objects-mastertabref
                      iv_field_name  = 'VBELN' ).

        READ TABLE <lt_likp> ASSIGNING FIELD-SYMBOL(<ls_likp>)
          WITH KEY vbeln = lv_vbeln.

        lv_lfuhr_old  = COND #( WHEN sy-subrc = 0 THEN <ls_likp>-lfuhr ).
      ENDIF.
    ENDIF.

    rv_result   = boolc( lv_lfuhr_new <> lv_lfuhr_old ).
  ENDMETHOD.

  METHOD lif_pe_filler~check_relevance.
    TYPES: tt_milestones    TYPE STANDARD TABLE OF /saptrx/appl_event_tag
                              WITH EMPTY KEY.

    IF is_time_of_delivery_changed( is_app_objects = is_app_objects ) = abap_true.
      rv_result = lif_ef_constants=>cs_condition-true.

    ELSE.
      DATA(lo_relevance_old)  = NEW lcl_dl_event_relevance(
                                      io_ef_parameters = mo_ef_parameters ).

      DATA(lo_relevance_new)  = NEW lcl_dl_event_relevance(
                                      io_ef_parameters = mo_ef_parameters
                                      is_app_objects   = is_app_objects ).

      DATA(lt_milestones)     = VALUE tt_milestones(
        ( lif_pof_constants=>cs_milestone-dl_goods_receipt )
        ( lif_pof_constants=>cs_milestone-dl_packing )
        ( lif_pof_constants=>cs_milestone-dl_put_away )
      ).

      rv_result = lif_ef_constants=>cs_condition-false.

      LOOP AT lt_milestones ASSIGNING FIELD-SYMBOL(<lv_milestone>).
        IF lo_relevance_old->is_enabled( iv_milestone = <lv_milestone> ) <>
             lo_relevance_new->is_enabled( iv_milestone = <lv_milestone> ).

          rv_result = lif_ef_constants=>cs_condition-true.
          EXIT.
        ENDIF.
      ENDLOOP.
    ENDIF.
  ENDMETHOD.

  METHOD lif_pe_filler~get_planed_events.
    DATA(lo_relevance)  = NEW lcl_dl_event_relevance(
                            io_ef_parameters = mo_ef_parameters
                            is_app_objects   = is_app_objects ).

    "" initiate relevance flags
    lo_relevance->initiate( ).

    "" store calculated relevance flags
    lo_relevance->update( ).

    add_put_away_event(
      EXPORTING
        is_app_objects  = is_app_objects
        io_relevance    = lo_relevance
      CHANGING
        ct_expeventdata = ct_expeventdata ).

    add_packing_event(
      EXPORTING
        is_app_objects  = is_app_objects
        io_relevance    = lo_relevance
      CHANGING
        ct_expeventdata = ct_expeventdata ).

    add_goods_receipt_event(
      EXPORTING
        is_app_objects  = is_app_objects
        io_relevance    = lo_relevance
      CHANGING
        ct_expeventdata = ct_expeventdata ).
  ENDMETHOD.
ENDCLASS.

**********************************************************************
*** Planned Events Shipment Header ***********************************
**********************************************************************
CLASS lcl_pe_filler_sh_item DEFINITION.
  PUBLIC SECTION.
    INTERFACES lif_pe_filler.

    METHODS constructor
      IMPORTING
        io_ef_parameters TYPE REF TO lif_ef_parameters
        io_bo_reader     TYPE REF TO lif_bo_reader
      RAISING
        cx_udm_message.

  PRIVATE SECTION.
    TYPES: tt_vbeln    TYPE RANGE OF lips-vbeln,
           tt_werks    TYPE RANGE OF lips-werks,
           tt_appobjid TYPE RANGE OF /saptrx/aoid.

    DATA: mo_ef_parameters TYPE REF TO lif_ef_parameters,
          mo_bo_reader     TYPE REF TO lif_bo_reader,
          mo_sh_data_old   TYPE REF TO lcl_sh_data_old.

    METHODS add_shipment_events
      IMPORTING
        is_app_objects  TYPE trxas_appobj_ctab_wa
      CHANGING
        ct_expeventdata TYPE lif_ef_types=>tt_expeventdata
        ct_measrmntdata TYPE lif_ef_types=>tt_measrmntdata
        ct_infodata     TYPE lif_ef_types=>tt_infodata
      RAISING
        cx_udm_message.

    METHODS add_stops_events
      IMPORTING
        is_app_objects  TYPE trxas_appobj_ctab_wa
      CHANGING
        ct_expeventdata TYPE lif_ef_types=>tt_expeventdata
        ct_measrmntdata TYPE lif_ef_types=>tt_measrmntdata
        ct_infodata     TYPE lif_ef_types=>tt_infodata
      RAISING
        cx_udm_message.

    METHODS get_shippment_header
      IMPORTING
        is_app_object  TYPE trxas_appobj_ctab_wa
        ir_vttk        TYPE REF TO data
      RETURNING
        VALUE(rr_vttk) TYPE REF TO data
      RAISING
        cx_udm_message.

    METHODS is_pod_relevant
      IMPORTING
        is_stops         TYPE lif_pof_types=>ts_stops
        it_vttp          TYPE vttpvb_tab
        it_vtsp          TYPE vtspvb_tab
      RETURNING
        VALUE(rv_result) TYPE abap_bool
      RAISING
        cx_udm_message.

    METHODS is_stop_changed
      IMPORTING
        is_app_object    TYPE trxas_appobj_ctab_wa
        it_fields        TYPE lif_ef_types=>tt_field_name
      RETURNING
        VALUE(rv_result) TYPE lif_ef_types=>tv_condition
      RAISING
        cx_udm_message.

    METHODS get_corresponding_dlv_items
      IMPORTING
        it_vbeln    TYPE tt_vbeln
        it_werks    TYPE tt_werks
      EXPORTING
        et_appobjid TYPE tt_appobjid
      RAISING
        cx_udm_message.

    METHODS get_header_fields
      EXPORTING
        et_fields TYPE lif_ef_types=>tt_field_name.

    METHODS get_stop_fields
      EXPORTING
        et_fields TYPE lif_ef_types=>tt_field_name.


ENDCLASS.

CLASS lcl_pe_filler_sh_item IMPLEMENTATION.
  METHOD add_shipment_events.
    FIELD-SYMBOLS: <ls_vttk>  TYPE vttkvb.

    ASSIGN is_app_objects-maintabref->* TO <ls_vttk>.

    IF <ls_vttk> IS ASSIGNED.
      "" CHECK IN
      ct_expeventdata = VALUE #( BASE ct_expeventdata (
        appsys            = mo_ef_parameters->get_appsys(  )
        appobjtype        = mo_ef_parameters->get_app_obj_types( )-aotype
        language          = sy-langu
        appobjid          = is_app_objects-appobjid
        milestone         = lif_pof_constants=>cs_milestone-sh_check_in
        evt_exp_datetime  = lcl_tools=>get_local_timestamp(
                              iv_date = <ls_vttk>-dpreg
                              iv_time = <ls_vttk>-upreg )
        evt_exp_tzone     = lcl_tools=>get_system_time_zone( )
      ) ).

      "" LOAD START
      ct_expeventdata = VALUE #( BASE ct_expeventdata (
        appsys            = mo_ef_parameters->get_appsys(  )
        appobjtype        = mo_ef_parameters->get_app_obj_types( )-aotype
        language          = sy-langu
        appobjid          = is_app_objects-appobjid
        milestone         = lif_pof_constants=>cs_milestone-sh_load_start
        evt_exp_datetime  = lcl_tools=>get_local_timestamp(
                              iv_date = <ls_vttk>-dplbg
                              iv_time = <ls_vttk>-uplbg )
        evt_exp_tzone     = lcl_tools=>get_system_time_zone( )
      ) ).

      "" LOAD END
      ct_expeventdata = VALUE #( BASE ct_expeventdata (
        appsys            = mo_ef_parameters->get_appsys(  )
        appobjtype        = mo_ef_parameters->get_app_obj_types( )-aotype
        language          = sy-langu
        appobjid          = is_app_objects-appobjid
        milestone         = lif_pof_constants=>cs_milestone-sh_load_end
        evt_exp_datetime  = lcl_tools=>get_local_timestamp(
                              iv_date = <ls_vttk>-dplen
                              iv_time = <ls_vttk>-uplen )
        evt_exp_tzone     = lcl_tools=>get_system_time_zone( )
      ) ).
    ENDIF.
  ENDMETHOD.

  METHOD add_stops_events.
    DATA(lv_tknum) = CONV tknum( lcl_tools=>get_field_of_structure(
                                   ir_struct_data = is_app_objects-maintabref
                                   iv_field_name  = 'TKNUM' ) ).

    DATA: lt_stops    TYPE lif_pof_types=>tt_stops.

    FIELD-SYMBOLS: <lt_vttp> TYPE vttpvb_tab,
                   <lt_vtts> TYPE vttsvb_tab,
                   <lt_vtsp> TYPE vtspvb_tab.

    DATA(lr_vttp) = mo_ef_parameters->get_appl_table(
                      iv_tabledef = lif_pof_constants=>cs_tabledef-sh_item_new ).
    DATA(lr_vtts) = mo_ef_parameters->get_appl_table(
                      iv_tabledef = lif_pof_constants=>cs_tabledef-sh_stage_new ).
    DATA(lr_vtsp) = mo_ef_parameters->get_appl_table(
                      iv_tabledef = lif_pof_constants=>cs_tabledef-sh_item_stage_new ).

    ASSIGN lr_vtts->* TO <lt_vtts>.
    ASSIGN lr_vttp->* TO <lt_vttp>.
    ASSIGN lr_vtsp->* TO <lt_vtsp>.

    IF <lt_vtts> IS ASSIGNED AND
       <lt_vtsp> IS ASSIGNED AND
       <lt_vttp> IS ASSIGNED.

      lcl_sh_tools=>get_stops_from_shipment(
        EXPORTING
          iv_tknum              = lv_tknum
          it_vtts               = <lt_vtts>
          it_vtsp               = <lt_vtsp>
          it_vttp               = <lt_vttp>
        IMPORTING
          et_stops              = lt_stops ).

      LOOP AT lt_stops ASSIGNING FIELD-SYMBOL(<ls_stops>).
        "" DEPARTURE / ARRIVAL
        ct_expeventdata = VALUE #( BASE ct_expeventdata (
          appsys            = mo_ef_parameters->get_appsys(  )
          appobjtype        = mo_ef_parameters->get_app_obj_types( )-aotype
          language          = sy-langu
          appobjid          = is_app_objects-appobjid
          milestone         = COND #( WHEN <ls_stops>-loccat = lif_pof_constants=>cs_loccat-departure
                                        THEN lif_pof_constants=>cs_milestone-sh_departure
                                        ELSE lif_pof_constants=>cs_milestone-sh_arrival )
          evt_exp_datetime  = <ls_stops>-pln_evt_datetime
          evt_exp_tzone     = <ls_stops>-pln_evt_timezone
          locid2            = <ls_stops>-stopid
          loctype           = <ls_stops>-loctype
          locid1            = <ls_stops>-locid
        ) ).

        IF is_pod_relevant( is_stops = <ls_stops>
                            it_vttp  = <lt_vttp>
                            it_vtsp  = <lt_vtsp> ) = abap_true.
          "" POD
          ct_expeventdata = VALUE #( BASE ct_expeventdata (
            appsys            = mo_ef_parameters->get_appsys(  )
            appobjtype        = mo_ef_parameters->get_app_obj_types( )-aotype
            language          = sy-langu
            appobjid          = is_app_objects-appobjid
            milestone         = lif_pof_constants=>cs_milestone-sh_pod
            evt_exp_datetime  = <ls_stops>-pln_evt_datetime
            evt_exp_tzone     = <ls_stops>-pln_evt_timezone
            locid2            = <ls_stops>-stopid
            loctype           = <ls_stops>-loctype
            locid1            = <ls_stops>-locid
          ) ).
        ENDIF.
      ENDLOOP.
    ELSE.
      MESSAGE e002(zpof_gtt) WITH 'VTTS' INTO DATA(lv_dummy).
      lcl_tools=>throw_exception( ).
    ENDIF.
  ENDMETHOD.

  METHOD constructor.
    mo_ef_parameters    = io_ef_parameters.
    mo_bo_reader        = io_bo_reader.
    mo_sh_data_old      = NEW lcl_sh_data_old(
                            io_ef_parameters = io_ef_parameters ).
  ENDMETHOD.

  METHOD get_shippment_header.
    TYPES: tt_vttk TYPE STANDARD TABLE OF vttkvb.

    FIELD-SYMBOLS: <lt_vttk> TYPE tt_vttk.

    DATA(lv_tknum)  = lcl_tools=>get_field_of_structure(
                        ir_struct_data = is_app_object-maintabref
                        iv_field_name  = 'TKNUM' ).

    ASSIGN ir_vttk->* TO <lt_vttk>.
    IF <lt_vttk> IS ASSIGNED.
      READ TABLE <lt_vttk> ASSIGNING FIELD-SYMBOL(<ls_vttk>)
        WITH KEY tknum = lv_tknum.

      IF sy-subrc = 0.
        rr_vttk = REF #( <ls_vttk> ).
      ELSE.
        MESSAGE e005(zpof_gtt) WITH 'VTTK OLD' lv_tknum
          INTO DATA(lv_dummy).
        lcl_tools=>throw_exception( ).
      ENDIF.
    ELSE.
      MESSAGE e002(zpof_gtt) WITH 'VTTK'
        INTO lv_dummy.
      lcl_tools=>throw_exception( ).
    ENDIF.
  ENDMETHOD.

  METHOD is_pod_relevant.
    DATA: lt_vbeln    TYPE RANGE OF lips-vbeln,
          lt_appobjid TYPE RANGE OF /saptrx/aoid,
          lv_locid    TYPE lif_pof_types=>tv_locid,
          lv_pdstk    TYPE pdstk.

    rv_result = abap_false.

    IF is_stops-loccat  = lif_pof_constants=>cs_loccat-arrival AND
       is_stops-loctype = lif_ef_constants=>cs_loc_types-plant.

      "" get Inbound Delivery Numbers
      LOOP AT it_vtsp ASSIGNING FIELD-SYMBOL(<ls_vtsp>)
        WHERE tknum = is_stops-tknum
          AND tsnum = is_stops-tsnum.

        READ TABLE it_vttp ASSIGNING FIELD-SYMBOL(<ls_vttp>)
          WITH KEY tknum = <ls_vtsp>-tknum
                   tpnum = <ls_vtsp>-tpnum.

        IF sy-subrc = 0.
          lt_vbeln[]    = VALUE #( BASE lt_vbeln
                                  ( option = 'EQ'
                                    sign   = 'I'
                                    low    = <ls_vttp>-vbeln ) ).
        ENDIF.
      ENDLOOP.

      "" get appobjid range (inbound deliveries for corresponding Plant)
      IF lt_vbeln[] IS NOT INITIAL.
        get_corresponding_dlv_items(
          EXPORTING
            it_vbeln    = lt_vbeln
            it_werks    = VALUE #( ( low = is_stops-locid
                                     option = 'EQ'
                                     sign   = 'I'  ) )
          IMPORTING
            et_appobjid = lt_appobjid ).
      ENDIF.

      "" get POD enabled flags for found DLV Items
      IF lt_appobjid[] IS NOT INITIAL.
        SELECT single z_pdstk   ""#EC CI_NOORDER
          INTO rv_result
          FROM zpof_gtt_ee_rel
          WHERE appobjid IN lt_appobjid
            AND z_pdstk   = abap_true.
      ENDIF.
    ENDIF.
  ENDMETHOD.

  METHOD is_stop_changed.
    FIELD-SYMBOLS: <lt_vtts_new> TYPE lif_pof_types=>tt_vttsvb,
                   <lt_vtts_old> TYPE lif_pof_types=>tt_vttsvb.

    DATA(lv_tknum)    = CONV tknum( lcl_tools=>get_field_of_structure(
                                      ir_struct_data = is_app_object-maintabref
                                      iv_field_name  = 'TKNUM' ) ).

    DATA(lr_vtts_new) = mo_ef_parameters->get_appl_table(
                          iv_tabledef = lif_pof_constants=>cs_tabledef-sh_stage_new ).
    DATA(lr_vtts_old) = mo_sh_data_old->get_vtts( ).

    rv_result   = lif_ef_constants=>cs_condition-false.

    ASSIGN lr_vtts_new->* TO <lt_vtts_new>.
    ASSIGN lr_vtts_old->* TO <lt_vtts_old>.

    IF <lt_vtts_new> IS ASSIGNED AND
       <lt_vtts_old> IS ASSIGNED.

      LOOP AT <lt_vtts_new> ASSIGNING FIELD-SYMBOL(<ls_vtts_new>)
        WHERE tknum = lv_tknum
          AND updkz IS NOT INITIAL.

        CASE <ls_vtts_new>-updkz.
          WHEN lif_ef_constants=>cs_change_mode-insert.
            rv_result   = lif_ef_constants=>cs_condition-true.

          WHEN lif_ef_constants=>cs_change_mode-update OR
               lif_ef_constants=>cs_change_mode-undefined.

            READ TABLE <lt_vtts_old> ASSIGNING FIELD-SYMBOL(<ls_vtts_old>)
              WITH KEY tknum  = <ls_vtts_new>-tknum
                       tsnum  = <ls_vtts_new>-tsnum.

            rv_result   = lcl_tools=>are_fields_different(
                  ir_data1  = REF #( <ls_vtts_new> )
                  ir_data2  = REF #( <ls_vtts_old> )
                  it_fields = it_fields ).
        ENDCASE.

        IF rv_result   = lif_ef_constants=>cs_condition-true.
          EXIT.
        ENDIF.
      ENDLOOP.

      IF rv_result   = lif_ef_constants=>cs_condition-false.
        LOOP AT <lt_vtts_old> TRANSPORTING NO FIELDS
          WHERE tknum = lv_tknum
            AND updkz = lif_ef_constants=>cs_change_mode-delete.

          rv_result   = lif_ef_constants=>cs_condition-true.
        ENDLOOP.
      ENDIF.
    ENDIF.

  ENDMETHOD.

  METHOD get_corresponding_dlv_items.
    DATA(lr_lips)   = mo_ef_parameters->get_appl_table(
                        iv_tabledef = lif_pof_constants=>cs_tabledef-sh_delivery_item ).

    FIELD-SYMBOLS: <lt_lips> TYPE vtrlp_tab.

    CLEAR: et_appobjid[].

    ASSIGN lr_lips->* TO <lt_lips>.

    IF <lt_lips> IS ASSIGNED.
      LOOP AT <lt_lips> ASSIGNING FIELD-SYMBOL(<ls_lips>)
        WHERE vbeln IN it_vbeln
          AND werks IN it_werks.

        et_appobjid = VALUE #( BASE et_appobjid (
                        low = |{ <ls_lips>-vbeln }{ <ls_lips>-posnr }|
                        option = 'EQ'
                        sign = 'I'
                      ) ).
      ENDLOOP.
    ELSE.
      MESSAGE e002(zpof_gtt) WITH 'LIPS' INTO DATA(lv_dummy).
      lcl_tools=>throw_exception( ).
    ENDIF.
  ENDMETHOD.

  METHOD get_header_fields.
    et_fields   = VALUE #( ( 'DPREG' ) ( 'UPREG' )
                           ( 'DPLBG' ) ( 'UPLBG' )
                           ( 'DPLEN' ) ( 'UPLEN' ) ).
  ENDMETHOD.

  METHOD get_stop_fields.
    et_fields   = VALUE #( ( 'DPTBG' ) ( 'UPTBG' )
                           ( 'DPTEN' ) ( 'UPTEN' )
                           ( 'KUNNA' ) ( 'KUNNZ' )
                           ( 'VSTEL' ) ( 'VSTEZ' )
                           ( 'LIFNA' ) ( 'LIFNZ' )
                           ( 'WERKA' ) ( 'WERKZ' )
                           ( 'KNOTA' ) ( 'KNOTZ' ) ).
  ENDMETHOD.

  METHOD lif_pe_filler~check_relevance.
    "" check the fields, used in PE extractor and not used in TP extractor

    "" check in, load start, load end
    get_header_fields(
      IMPORTING
        et_fields = DATA(lt_header_fields) ).

    rv_result = lcl_tools=>are_fields_different(
                  ir_data1  = is_app_objects-maintabref
                  ir_data2  = get_shippment_header(
                                is_app_object = is_app_objects
                                ir_vttk       = mo_sh_data_old->get_vttk( ) )
                  it_fields = lt_header_fields ).

    "" departure, arrival
    IF rv_result = lif_ef_constants=>cs_condition-false.
      get_stop_fields(
        IMPORTING
          et_fields = DATA(lt_stop_fields) ).

      rv_result = is_stop_changed(
                    is_app_object = is_app_objects
                    it_fields     = lt_stop_fields ).

    ENDIF.
  ENDMETHOD.

  METHOD lif_pe_filler~get_planed_events.
    add_shipment_events(
      EXPORTING
        is_app_objects  = is_app_objects
      CHANGING
        ct_expeventdata = ct_expeventdata
        ct_measrmntdata = ct_measrmntdata
        ct_infodata     = ct_infodata ).

    add_stops_events(
      EXPORTING
        is_app_objects  = is_app_objects
      CHANGING
        ct_expeventdata = ct_expeventdata
        ct_measrmntdata = ct_measrmntdata
        ct_infodata     = ct_infodata ).

    IF NOT line_exists( ct_expeventdata[ appobjid = is_app_objects-appobjid ] ).
      "" planned events DELETION
      ct_expeventdata = VALUE #( BASE ct_expeventdata (
        appsys            = mo_ef_parameters->get_appsys(  )
        appobjtype        = mo_ef_parameters->get_app_obj_types( )-aotype
        language          = sy-langu
        appobjid          = is_app_objects-appobjid
        milestone         = ''
        evt_exp_datetime  = '000000000000000'
        evt_exp_tzone     = ''
      ) ).
    ENDIF.
  ENDMETHOD.
ENDCLASS.
",10155,False,2366.9232659901327,median
"== Video Options

=== Composite Video Mode

==== `sdtv_mode`

The `sdtv_mode` command defines the TV standard used for composite video output. On the original Raspberry Pi, composite video is output on the RCA socket. On other Raspberry Pis, except for Raspberry Pi Zero and Compute Module, composite video is output along with sound on the 4 pole TRRS (""headphone"") socket. On the Raspberry Pi Zero, there is an unpopulated header labelled ""TV"" which outputs composite video. On the Compute Module, composite video is available via the TVDAC pin. The default value of `sdtv_mode` is `0`.

|===
| sdtv_mode | result

| 0
| Normal NTSC

| 1
| Japanese version of NTSC -- no pedestal

| 2
| Normal PAL

| 3
| Brazilian version of PAL -- 525/60 rather than 625/50, different subcarrier

| 16
| Progressive scan NTSC

| 18
| Progressive scan PAL
|===

==== `sdtv_aspect`

The `sdtv_aspect` command defines the aspect ratio for composite video output. The default value is `1`.

|===
| sdtv_aspect | result

| 1
| 4:3

| 2
| 14:9

| 3
| 16:9
|===

==== `sdtv_disable_colourburst`

Setting `sdtv_disable_colourburst` to `1` disables colourburst on composite video output. The picture will be displayed in monochrome, but it may appear sharper.

==== `enable_tvout` (Raspberry Pi 4 Model B Only)

On the Raspberry Pi 4, composite output is disabled by default, due to the way the internal clocks are interrelated and allocated. Because composite video requires a very specific clock, setting that clock to the required speed on the Raspberry Pi 4 means that other clocks connected to it are detrimentally affected, which slightly slows down the entire system. Since composite video is a less commonly used function, we decided to disable it by default to prevent this system slowdown.

To enable composite output, use the `enable_tvout=1` option. As described above, this will detrimentally affect performance to a small degree.

On older Raspberry Pi models, the composite behaviour remains the same.

=== HDMI Mode

NOTE: Because the Raspberry Pi 4 and Raspberry Pi 400 have two HDMI ports, some HDMI commands can be applied to either port. You can use the syntax `<command>:<port>`, where port is 0 or 1, to specify which port the setting should apply to. If no port is specified, the default is 0. If you specify a port number on a command that does not require a port number, the port is ignored. Further details on the syntax and alternatives mechanisms can be found in the HDMI sub-section of the xref:config_txt.adoc#conditional-filters[conditionals section] of the documentation.

In order to support dual 4k displays, the Raspberry Pi 4 has xref:config_txt.adoc#raspberry-pi-4-hdmi-pipeline[updated video hardware], which imposes minor restrictions on the modes supported.

==== `hdmi_safe`

Setting `hdmi_safe` to `1` will lead to ""safe mode"" settings being used to try to boot with maximum HDMI compatibility. This is the same as setting the following parameters:

----
hdmi_force_hotplug=1
hdmi_ignore_edid=0xa5000080
config_hdmi_boost=4
hdmi_group=2
hdmi_mode=4
disable_overscan=0
overscan_left=24
overscan_right=24
overscan_top=24
overscan_bottom=24
----

==== `hdmi_ignore_edid`

Setting `hdmi_ignore_edid` to `0xa5000080` enables the ignoring of EDID/display data if your display does not have an accurate https://en.wikipedia.org/wiki/Extended_display_identification_data[EDID]. It requires this unusual value to ensure that it is not triggered accidentally.

==== `hdmi_edid_file`

Setting `hdmi_edid_file` to `1` will cause the GPU to read EDID data from the `edid.dat` file, located in the boot partition, instead of reading it from the monitor. More information is available https://forums.raspberrypi.com/viewtopic.php?p=173430#p173430[on the forums].

==== `hdmi_edid_filename`

On the Raspberry Pi 4B, you can use the `hdmi_edid_filename` command to specify the filename of the EDID file to use, and also to specify which port the file is to be applied to. This also requires `hdmi_edid_file=1` to enable EDID files.

For example:

----
hdmi_edid_file=1
hdmi_edid_filename:0=FileForPortZero.edid
hdmi_edid_filename:1=FileForPortOne.edid
----

==== `hdmi_force_edid_audio`

Setting `hdmi_force_edid_audio` to `1` pretends that all audio formats are supported by the display, allowing passthrough of DTS/AC3 even when this is not reported as supported.

==== `hdmi_ignore_edid_audio`

Setting `hdmi_ignore_edid_audio` to `1` pretends that all audio formats are unsupported by the display. This means ALSA will default to the analogue audio (headphone) jack.

==== `hdmi_force_edid_3d`

Setting `hdmi_force_edid_3d` to `1` pretends that all CEA modes support 3D, even when the EDID does not indicate support for this.

==== `hdmi_ignore_cec_init`

Setting `hdmi_ignore_cec_init` to `1` will stop the initial active source message being sent during bootup. This prevents a CEC-enabled TV from coming out of standby and channel-switching when you are rebooting your Raspberry Pi.

==== `hdmi_ignore_cec`

Setting `hdmi_ignore_cec` to `1` pretends that https://en.wikipedia.org/wiki/Consumer_Electronics_Control#CEC[CEC] is not supported at all by the TV. No CEC functions will be supported.

==== `cec_osd_name`

The `cec_osd_name` command sets the initial CEC name of the device. The default is Raspberry Pi.

==== `hdmi_pixel_encoding`

The `hdmi_pixel_encoding` command forces the pixel encoding mode. By default, it will use the mode requested from the EDID, so you shouldn't need to change it.

|===
| hdmi_pixel_encoding | result

| 0
| default (RGB limited for CEA, RGB full for DMT)

| 1
| RGB limited (16-235)

| 2
| RGB full (0-255)

| 3
| YCbCr limited (16-235)

| 4
| YCbCr full (0-255)
|===

==== `hdmi_max_pixel_freq`

The pixel frequency is used by the firmware and KMS to filter HDMI modes. Note, this is not the same as the frame rate. It specifies the maximum frequency that a valid mode can have, thereby culling out higher frequency modes. So for example, if you wish to disable all 4K modes, you could specify a maximum frequency of 200000000, since all 4K modes have frequencies greater than this.

==== `hdmi_blanking`

The `hdmi_blanking` command controls what happens when the operating system asks for the display to be put into standby mode, using DPMS, to save power. If this option is not set or set to 0, the HDMI output is blanked but not switched off. In order to mimic the behaviour of other computers, you can set the HDMI output to switch off as well by setting this option to 1: the attached display will go into a low power standby mode.

NOTE: On the Raspberry Pi 4, setting `hdmi_blanking=1` will not cause the HDMI output to be switched off, since this feature has not yet been implemented. This feature may cause issues when using applications which don't use the framebuffer, such as `omxplayer`.

|===
| hdmi_blanking | result

| 0
| HDMI output will be blanked

| 1
| HDMI output will be switched off and blanked
|===

==== `hdmi_drive`

The `hdmi_drive` command allows you to choose between HDMI and DVI output modes.

|===
| hdmi_drive | result

| 1
| Normal DVI mode (no sound)

| 2
| Normal HDMI mode (sound will be sent if supported and enabled)
|===

==== `config_hdmi_boost`

Configures the signal strength of the HDMI interface. The minimum value is `0` and the maximum is `11`.

The default value for the original Model B and A is `2`. The default value for the Model B+ and all later models is `5`.

If you are seeing HDMI issues (speckling, interference) then try `7`. Very long HDMI cables may need up to `11`, but values this high should not be used unless absolutely necessary.

This option is ignored on the Raspberry Pi 4.

==== `hdmi_group`

The `hdmi_group` command defines the HDMI output group to be either CEA (Consumer Electronics Association, the standard typically used by TVs) or DMT (Display Monitor Timings, the standard typically used by monitors). This setting should be used in conjunction with `hdmi_mode`.

|===
| hdmi_group | result

| 0
| Auto-detect from EDID

| 1
| CEA

| 2
| DMT
|===

==== `hdmi_mode`

Together with `hdmi_group`, `hdmi_mode` defines the HDMI output format. Format mode numbers are derived from the https://web.archive.org/web/20171201033424/https://standards.cta.tech/kwspub/published_docs/CTA-861-G_FINAL_revised_2017.pdf[CTA specification].

To set a custom display mode not listed here, see more information on https://forums.raspberrypi.com/viewtopic.php?f=29&t=24679[the forums].

NOTE: Not all modes are available on all models.

These values are valid if `hdmi_group=1` (CEA):

[cols="",,,^,""]
|===
| hdmi_mode | Resolution | Frequency | Screen Aspect | Notes

| 1
| VGA (640x480)
| 60Hz
| 4:3
|

| 2
| 480p
| 60Hz
| 4:3
|

| 3
| 480p
| 60Hz
| 16:9
|

| 4
| 720p
| 60Hz
| 16:9
|

| 5
| 1080i
| 60Hz
| 16:9
|

| 6
| 480i
| 60Hz
| 4:3
|

| 7
| 480i
| 60Hz
| 16:9
|

| 8
| 240p
| 60Hz
| 4:3
|

| 9
| 240p
| 60Hz
| 16:9
|

| 10
| 480i
| 60Hz
| 4:3
| pixel quadrupling

| 11
| 480i
| 60Hz
| 16:9
| pixel quadrupling

| 12
| 240p
| 60Hz
| 4:3
| pixel quadrupling

| 13
| 240p
| 60Hz
| 16:9
| pixel quadrupling

| 14
| 480p
| 60Hz
| 4:3
| pixel doubling

| 15
| 480p
| 60Hz
| 16:9
| pixel doubling

| 16
| 1080p
| 60Hz
| 16:9
|

| 17
| 576p
| 50Hz
| 4:3
|

| 18
| 576p
| 50Hz
| 16:9
|

| 19
| 720p
| 50Hz
| 16:9
|

| 20
| 1080i
| 50Hz
| 16:9
|

| 21
| 576i
| 50Hz
| 4:3
|

| 22
| 576i
| 50Hz
| 16:9
|

| 23
| 288p
| 50Hz
| 4:3
|

| 24
| 288p
| 50Hz
| 16:9
|

| 25
| 576i
| 50Hz
| 4:3
| pixel quadrupling

| 26
| 576i
| 50Hz
| 16:9
| pixel quadrupling

| 27
| 288p
| 50Hz
| 4:3
| pixel quadrupling

| 28
| 288p
| 50Hz
| 16:9
| pixel quadrupling

| 29
| 576p
| 50Hz
| 4:3
| pixel doubling

| 30
| 576p
| 50Hz
| 16:9
| pixel doubling

| 31
| 1080p
| 50Hz
| 16:9
|

| 32
| 1080p
| 24Hz
| 16:9
|

| 33
| 1080p
| 25Hz
| 16:9
|

| 34
| 1080p
| 30Hz
| 16:9
|

| 35
| 480p
| 60Hz
| 4:3
| pixel quadrupling

| 36
| 480p
| 60Hz
| 16:9
| pixel quadrupling

| 37
| 576p
| 50Hz
| 4:3
| pixel quadrupling

| 38
| 576p
| 50Hz
| 16:9
| pixel quadrupling

| 39
| 1080i
| 50Hz
| 16:9
| reduced blanking

| 40
| 1080i
| 100Hz
| 16:9
|

| 41
| 720p
| 100Hz
| 16:9
|

| 42
| 576p
| 100Hz
| 4:3
|

| 43
| 576p
| 100Hz
| 16:9
|

| 44
| 576i
| 100Hz
| 4:3
|

| 45
| 576i
| 100Hz
| 16:9
|

| 46
| 1080i
| 120Hz
| 16:9
|

| 47
| 720p
| 120Hz
| 16:9
|

| 48
| 480p
| 120Hz
| 4:3
|

| 49
| 480p
| 120Hz
| 16:9
|

| 50
| 480i
| 120Hz
| 4:3
|

| 51
| 480i
| 120Hz
| 16:9
|

| 52
| 576p
| 200Hz
| 4:3
|

| 53
| 576p
| 200Hz
| 16:9
|

| 54
| 576i
| 200Hz
| 4:3
|

| 55
| 576i
| 200Hz
| 16:9
|

| 56
| 480p
| 240Hz
| 4:3
|

| 57
| 480p
| 240Hz
| 16:9
|

| 58
| 480i
| 240Hz
| 4:3
|

| 59
| 480i
| 240Hz
| 16:9
|

| 60
| 720p
| 24Hz
| 16:9
|

| 61
| 720p
| 25Hz
| 16:9
|

| 62
| 720p
| 30Hz
| 16:9
|

| 63
| 1080p
| 120Hz
| 16:9
|

| 64
| 1080p
| 100Hz
| 16:9
|

| 65
| Custom
|
|
|

| 66
| 720p
| 25Hz
| 64:27
| Pi 4

| 67
| 720p
| 30Hz
| 64:27
| Pi 4

| 68
| 720p
| 50Hz
| 64:27
| Pi 4

| 69
| 720p
| 60Hz
| 64:27
| Pi 4

| 70
| 720p
| 100Hz
| 64:27
| Pi 4

| 71
| 720p
| 120Hz
| 64:27
| Pi 4

| 72
| 1080p
| 24Hz
| 64:27
| Pi 4

| 73
| 1080p
| 25Hz
| 64:27
| Pi 4

| 74
| 1080p
| 30Hz
| 64:27
| Pi 4

| 75
| 1080p
| 50Hz
| 64:27
| Pi 4

| 76
| 1080p
| 60Hz
| 64:27
| Pi 4

| 77
| 1080p
| 100Hz
| 64:27
| Pi 4

| 78
| 1080p
| 120Hz
| 64:27
| Pi 4

| 79
| 1680x720
| 24Hz
| 64:27
| Pi 4

| 80
| 1680x720
| 25z
| 64:27
| Pi 4

| 81
| 1680x720
| 30Hz
| 64:27
| Pi 4

| 82
| 1680x720
| 50Hz
| 64:27
| Pi 4

| 83
| 1680x720
| 60Hz
| 64:27
| Pi 4

| 84
| 1680x720
| 100Hz
| 64:27
| Pi 4

| 85
| 1680x720
| 120Hz
| 64:27
| Pi 4

| 86
| 2560x720
| 24Hz
| 64:27
| Pi 4

| 87
| 2560x720
| 25Hz
| 64:27
| Pi 4

| 88
| 2560x720
| 30Hz
| 64:27
| Pi 4

| 89
| 2560x720
| 50Hz
| 64:27
| Pi 4

| 90
| 2560x720
| 60Hz
| 64:27
| Pi 4

| 91
| 2560x720
| 100Hz
| 64:27
| Pi 4

| 92
| 2560x720
| 120Hz
| 64:27
| Pi 4

| 93
| 2160p
| 24Hz
| 16:9
| Pi 4

| 94
| 2160p
| 25Hz
| 16:9
| Pi 4

| 95
| 2160p
| 30Hz
| 16:9
| Pi 4

| 96
| 2160p
| 50Hz
| 16:9
| Pi 4

| 97
| 2160p
| 60Hz
| 16:9
| Pi 4

| 98
| 4096x2160
| 24Hz
| 256:135
| Pi 4

| 99
| 4096x2160
| 25Hz
| 256:135
| Pi 4

| 100
| 4096x2160
| 30Hz
| 256:135
| Pi 4

| 101
| 4096x2160
| 50Hz
| 256:135
| Pi 4

| 102
| 4096x2160
| 60Hz
| 256:135
| Pi 4

| 103
| 2160p
| 24Hz
| 64:27
| Pi 4

| 104
| 2160p
| 25Hz
| 64:27
| Pi 4

| 105
| 2160p
| 30Hz
| 64:27
| Pi 4

| 106
| 2160p
| 50Hz
| 64:27
| Pi 4

| 107
| 2160p
| 60Hz
| 64:27
| Pi 4
|===

Pixel doubling and quadrupling indicates a higher clock rate, with each pixel repeated two or four times respectively.

These values are valid if `hdmi_group=2` (DMT):

[cols="",,,^,""]
|===
| hdmi_mode | Resolution | Frequency | Screen Aspect | Notes

| 1
| 640x350
| 85Hz
|
|

| 2
| 640x400
| 85Hz
| 16:10
|

| 3
| 720x400
| 85Hz
|
|

| 4
| 640x480
| 60Hz
| 4:3
|

| 5
| 640x480
| 72Hz
| 4:3
|

| 6
| 640x480
| 75Hz
| 4:3
|

| 7
| 640x480
| 85Hz
| 4:3
|

| 8
| 800x600
| 56Hz
| 4:3
|

| 9
| 800x600
| 60Hz
| 4:3
|

| 10
| 800x600
| 72Hz
| 4:3
|

| 11
| 800x600
| 75Hz
| 4:3
|

| 12
| 800x600
| 85Hz
| 4:3
|

| 13
| 800x600
| 120Hz
| 4:3
|

| 14
| 848x480
| 60Hz
| 16:9
|

| 15
| 1024x768
| 43Hz
| 4:3
| incompatible with the Raspberry Pi

| 16
| 1024x768
| 60Hz
| 4:3
|

| 17
| 1024x768
| 70Hz
| 4:3
|

| 18
| 1024x768
| 75Hz
| 4:3
|

| 19
| 1024x768
| 85Hz
| 4:3
|

| 20
| 1024x768
| 120Hz
| 4:3
|

| 21
| 1152x864
| 75Hz
| 4:3
|

| 22
| 1280x768
| 60Hz
| 15:9
| reduced blanking

| 23
| 1280x768
| 60Hz
| 15:9
|

| 24
| 1280x768
| 75Hz
| 15:9
|

| 25
| 1280x768
| 85Hz
| 15:9
|

| 26
| 1280x768
| 120Hz
| 15:9
| reduced blanking

| 27
| 1280x800
| 60
| 16:10
| reduced blanking

| 28
| 1280x800
| 60Hz
| 16:10
|

| 29
| 1280x800
| 75Hz
| 16:10
|

| 30
| 1280x800
| 85Hz
| 16:10
|

| 31
| 1280x800
| 120Hz
| 16:10
| reduced blanking

| 32
| 1280x960
| 60Hz
| 4:3
|

| 33
| 1280x960
| 85Hz
| 4:3
|

| 34
| 1280x960
| 120Hz
| 4:3
| reduced blanking

| 35
| 1280x1024
| 60Hz
| 5:4
|

| 36
| 1280x1024
| 75Hz
| 5:4
|

| 37
| 1280x1024
| 85Hz
| 5:4
|

| 38
| 1280x1024
| 120Hz
| 5:4
| reduced blanking

| 39
| 1360x768
| 60Hz
| 16:9
|

| 40
| 1360x768
| 120Hz
| 16:9
| reduced blanking

| 41
| 1400x1050
| 60Hz
| 4:3
| reduced blanking

| 42
| 1400x1050
| 60Hz
| 4:3
|

| 43
| 1400x1050
| 75Hz
| 4:3
|

| 44
| 1400x1050
| 85Hz
| 4:3
|

| 45
| 1400x1050
| 120Hz
| 4:3
| reduced blanking

| 46
| 1440x900
| 60Hz
| 16:10
| reduced blanking

| 47
| 1440x900
| 60Hz
| 16:10
|

| 48
| 1440x900
| 75Hz
| 16:10
|

| 49
| 1440x900
| 85Hz
| 16:10
|

| 50
| 1440x900
| 120Hz
| 16:10
| reduced blanking

| 51
| 1600x1200
| 60Hz
| 4:3
|

| 52
| 1600x1200
| 65Hz
| 4:3
|

| 53
| 1600x1200
| 70Hz
| 4:3
|

| 54
| 1600x1200
| 75Hz
| 4:3
|

| 55
| 1600x1200
| 85Hz
| 4:3
|

| 56
| 1600x1200
| 120Hz
| 4:3
| reduced blanking

| 57
| 1680x1050
| 60Hz
| 16:10
| reduced blanking

| 58
| 1680x1050
| 60Hz
| 16:10
|

| 59
| 1680x1050
| 75Hz
| 16:10
|

| 60
| 1680x1050
| 85Hz
| 16:10
|

| 61
| 1680x1050
| 120Hz
| 16:10
| reduced blanking

| 62
| 1792x1344
| 60Hz
| 4:3
|

| 63
| 1792x1344
| 75Hz
| 4:3
|

| 64
| 1792x1344
| 120Hz
| 4:3
| reduced blanking

| 65
| 1856x1392
| 60Hz
| 4:3
|

| 66
| 1856x1392
| 75Hz
| 4:3
|

| 67
| 1856x1392
| 120Hz
| 4:3
| reduced blanking

| 68
| 1920x1200
| 60Hz
| 16:10
| reduced blanking

| 69
| 1920x1200
| 60Hz
| 16:10
|

| 70
| 1920x1200
| 75Hz
| 16:10
|

| 71
| 1920x1200
| 85Hz
| 16:10
|

| 72
| 1920x1200
| 120Hz
| 16:10
| reduced blanking

| 73
| 1920x1440
| 60Hz
| 4:3
|

| 74
| 1920x1440
| 75Hz
| 4:3
|

| 75
| 1920x1440
| 120Hz
| 4:3
| reduced blanking

| 76
| 2560x1600
| 60Hz
| 16:10
| reduced blanking

| 77
| 2560x1600
| 60Hz
| 16:10
|

| 78
| 2560x1600
| 75Hz
| 16:10
|

| 79
| 2560x1600
| 85Hz
| 16:10
|

| 80
| 2560x1600
| 120Hz
| 16:10
| reduced blanking

| 81
| 1366x768
| 60Hz
| 16:9
| xref:config_txt.adoc#raspberry-pi-4-hdmi-pipeline[NOT on Raspberry Pi 4]

| 82
| 1920x1080
| 60Hz
| 16:9
| 1080p

| 83
| 1600x900
| 60Hz
| 16:9
| reduced blanking

| 84
| 2048x1152
| 60Hz
| 16:9
| reduced blanking

| 85
| 1280x720
| 60Hz
| 16:9
| 720p

| 86
| 1366x768
| 60Hz
| 16:9
| reduced blanking
|===

NOTE: There is a https://forums.raspberrypi.com/viewtopic.php?f=26&t=20155&p=195443#p195443[pixel clock limit]. The highest supported mode on models prior to the Raspberry Pi 4 is 1920x1200 at 60Hz with reduced blanking, whilst the Raspberry Pi 4 can support up to 4096x2160 (known as 4k) at 60Hz. Also note that if you are using both HDMI ports of the Raspberry Pi 4 for 4k output, then you are limited to 30Hz on both.

==== `hdmi_timings`

This allows setting of raw HDMI timing values for a custom mode, selected using `hdmi_group=2` and `hdmi_mode=87`.

[source]
----
hdmi_timings=<h_active_pixels> <h_sync_polarity> <h_front_porch> <h_sync_pulse> <h_back_porch> <v_active_lines> <v_sync_polarity> <v_front_porch> <v_sync_pulse> <v_back_porch> <v_sync_offset_a> <v_sync_offset_b> <pixel_rep> <frame_rate> <interlaced> <pixel_freq> <aspect_ratio>
----

[source]
----
<h_active_pixels> = horizontal pixels (width)
<h_sync_polarity> = invert hsync polarity
<h_front_porch>   = horizontal forward padding from DE active edge
<h_sync_pulse>    = hsync pulse width in pixel clocks
<h_back_porch>    = vertical back padding from DE active edge
<v_active_lines>  = vertical pixels height (lines)
<v_sync_polarity> = invert vsync polarity
<v_front_porch>   = vertical forward padding from DE active edge
<v_sync_pulse>    = vsync pulse width in pixel clocks
<v_back_porch>    = vertical back padding from DE active edge
<v_sync_offset_a> = leave at zero
<v_sync_offset_b> = leave at zero
<pixel_rep>       = leave at zero
<frame_rate>      = screen refresh rate in Hz
<interlaced>      = leave at zero
<pixel_freq>      = clock frequency (width*height*framerate)
<aspect_ratio>    = *
----

`*` The aspect ratio can be set to one of eight values (choose the closest for your screen):

[source]
----
HDMI_ASPECT_4_3 = 1
HDMI_ASPECT_14_9 = 2
HDMI_ASPECT_16_9 = 3
HDMI_ASPECT_5_4 = 4
HDMI_ASPECT_16_10 = 5
HDMI_ASPECT_15_9 = 6
HDMI_ASPECT_21_9 = 7
HDMI_ASPECT_64_27 = 8
----

==== `hdmi_force_mode`

Setting to `1` will remove all other modes except the ones specified by `hdmi_mode` and `hdmi_group` from the internal list, meaning they will not appear in any enumerated lists of modes. This option may help if a display seems to be ignoring the `hdmi_mode` and `hdmi_group` settings.

==== `edid_content_type`

Forces the EDID content type to a specific value.

The options are:

* `0` = `EDID_ContentType_NODATA`, content type none.
* `1` = `EDID_ContentType_Graphics`, content type graphics, ITC must be set to 1
* `2` = `EDID_ContentType_Photo`, content type photo
* `3` = `EDID_ContentType_Cinema`,  content type cinema
* `4` = `EDID_ContentType_Game`,  content type game

=== Which Values are Valid for my Monitor?

Your HDMI monitor may only support a limited set of formats. To find out which formats are supported, use the following method:

. Set the output format to VGA 60Hz (`hdmi_group=1` and `hdmi_mode=1`) and boot up your Raspberry Pi
. Enter the following command to give a list of CEA-supported modes: `/opt/vc/bin/tvservice -m CEA`
. Enter the following command to give a list of DMT-supported modes: `/opt/vc/bin/tvservice -m DMT`
. Enter the following command to show your current state: `/opt/vc/bin/tvservice -s`
. Enter the following commands to dump more detailed information from your monitor: `/opt/vc/bin/tvservice -d edid.dat; /opt/vc/bin/edidparser edid.dat`

The `edid.dat` should also be provided when troubleshooting problems with the default HDMI mode.

[[custom-mode]]
=== Custom Mode

If your monitor requires a mode that is not in one of the tables above, then it's possible to define a custom CVT mode for it instead:

[source]
----
hdmi_cvt=<width> <height> <framerate> <aspect> <margins> <interlace> <rb>
----

|===
| Value | Default | Description

| width
| (required)
| width in pixels

| height
| (required)
| height in pixels

| framerate
| (required)
| framerate in Hz

| aspect
| 3
| aspect ratio 1=4:3, 2=14:9, 3=16:9, 4=5:4, 5=16:10, 6=15:9

| margins
| 0
| 0=margins disabled, 1=margins enabled

| interlace
| 0
| 0=progressive, 1=interlaced

| rb
| 0
| 0=normal, 1=reduced blanking
|===

Fields at the end can be omitted to use the default values.

Note that this simply *creates* the mode (group 2 mode 87). In order to make the Raspberry Pi use this by default, you must add some additional settings. For example, the following selects an 800 × 480 resolution and enables audio drive:

----
hdmi_cvt=800 480 60 6
hdmi_group=2
hdmi_mode=87
hdmi_drive=2
----

This may not work if your monitor does not support standard CVT timings.

=== LCD Displays and Touchscreens

==== `ignore_lcd`

By default the Raspberry Pi Touch Display is used when it is detected on the I2C bus. `ignore_lcd=1` will skip this detection phase, and therefore the LCD display will not be used.

==== `display_default_lcd`

If a Raspberry Pi Touch Display is detected it will be used as the default display and will show the framebuffer. Setting `display_default_lcd=0` will ensure the LCD is not the default display, which usually implies the HDMI output will be the default. The LCD can still be used by choosing its display number from supported applications, for example, omxplayer.

==== `lcd_framerate`

Specify the framerate of the Raspberry Pi Touch Display, in Hertz/fps. Defaults to 60Hz.

==== `lcd_rotate`

This flips the display using the LCD's inbuilt flip functionality, which is a cheaper operation that using the GPU-based rotate operation.

For example, `lcd_rotate=2` will compensate for an upside down display.

==== `disable_touchscreen`

Enable/disable the touchscreen.

`disable_touchscreen=1` will disable the touchscreen on the official Raspberry Pi Touch Display.

==== `enable_dpi_lcd`

Enable LCD displays attached to the DPI GPIOs. This is to allow the use of third-party LCD displays using the parallel display interface.

==== `dpi_group`, `dpi_mode`, `dpi_output_format`

The `dpi_group` and `dpi_mode` `config.txt` parameters are used to set either predetermined modes (DMT or CEA modes as used by HDMI above). A user can generate custom modes in much the same way as for HDMI (see `dpi_timings` section).

`dpi_output_format` is a bitmask specifying various parameters used to set up the display format.

==== `dpi_timings`

This allows setting of raw DPI timing values for a custom mode, selected using `dpi_group=2` and `dpi_mode=87`.

[source]
----
dpi_timings=<h_active_pixels> <h_sync_polarity> <h_front_porch> <h_sync_pulse> <h_back_porch> <v_active_lines> <v_sync_polarity> <v_front_porch> <v_sync_pulse> <v_back_porch> <v_sync_offset_a> <v_sync_offset_b> <pixel_rep> <frame_rate> <interlaced> <pixel_freq> <aspect_ratio>
----

[source]
----
<h_active_pixels> = horizontal pixels (width)
<h_sync_polarity> = invert hsync polarity
<h_front_porch>   = horizontal forward padding from DE active edge
<h_sync_pulse>    = hsync pulse width in pixel clocks
<h_back_porch>    = vertical back padding from DE active edge
<v_active_lines>  = vertical pixels height (lines)
<v_sync_polarity> = invert vsync polarity
<v_front_porch>   = vertical forward padding from DE active edge
<v_sync_pulse>    = vsync pulse width in pixel clocks
<v_back_porch>    = vertical back padding from DE active edge
<v_sync_offset_a> = leave at zero
<v_sync_offset_b> = leave at zero
<pixel_rep>       = leave at zero
<frame_rate>      = screen refresh rate in Hz
<interlaced>      = leave at zero
<pixel_freq>      = clock frequency (width*height*framerate)
<aspect_ratio>    = *
----

`*` The aspect ratio can be set to one of eight values (choose the closest for your screen):

----
HDMI_ASPECT_4_3 = 1
HDMI_ASPECT_14_9 = 2
HDMI_ASPECT_16_9 = 3
HDMI_ASPECT_5_4 = 4
HDMI_ASPECT_16_10 = 5
HDMI_ASPECT_15_9 = 6
HDMI_ASPECT_21_9 = 7
HDMI_ASPECT_64_27 = 8
----

=== Generic Display Options

==== `hdmi_force_hotplug`

Setting `hdmi_force_hotplug` to `1` pretends that the HDMI hotplug signal is asserted, so it appears that a HDMI display is attached. In other words, HDMI output mode will be used, even if no HDMI monitor is detected.

==== `hdmi_ignore_hotplug`

Setting `hdmi_ignore_hotplug` to `1` pretends that the HDMI hotplug signal is not asserted, so it appears that a HDMI display is not attached. In other words, composite output mode will be used, even if an HDMI monitor is detected.

==== `overscan_left`

The `overscan_left` command specifies the number of pixels to add to the firmware default value of overscan on the left edge of the screen. The default value is `0`.

Increase this value if the text flows off the left edge of the screen; decrease it if there is a black border between the left edge of the screen and the text.

==== `overscan_right`

The `overscan_right` command specifies the number of pixels to add to the firmware default value of overscan on the right edge of the screen. The default value is `0`.

Increase this value if the text flows off the right edge of the screen; decrease it if there is a black border between the right edge of the screen and the text.

==== `overscan_top`

The `overscan_top` command specifies the number of pixels to add to the firmware default value of overscan on the top edge of the screen. The default value is `0`.

Increase this value if the text flows off the top edge of the screen; decrease it if there is a black border between the top edge of the screen and the text.

==== `overscan_bottom`

The `overscan_bottom` command specifies the number of pixels to add to the firmware default value of overscan on the bottom edge of the screen. The default value is `0`.

Increase this value if the text flows off the bottom edge of the screen; decrease it if there is a black border between the bottom edge of the screen and the text.

==== `overscan_scale`

Set `overscan_scale` to `1` to force any non-framebuffer layers to conform to the overscan settings. The default value is `0`.

*NOTE:* this feature is generally not recommended: it can reduce image quality because all layers on the display will be scaled by the GPU. Disabling overscan on the display itself is the recommended option to avoid images being scaled twice (by the GPU and the display).

==== `framebuffer_width`

The `framebuffer_width` command specifies the console framebuffer width in pixels. The default is the display width minus the total horizontal overscan.

==== `framebuffer_height`

The `framebuffer_height` command specifies the console framebuffer height in pixels. The default is the display height minus the total vertical overscan.

==== `max_framebuffer_height`, `max_framebuffer_width`

Specifies the maximum dimensions that the internal frame buffer is allowed to be.

==== `framebuffer_depth`

Use `framebuffer_depth` to specify the console framebuffer depth in bits per pixel. The default value is `16`.

|===
| framebuffer_depth | result | notes

| 8
| 8bit framebuffer
| Default RGB palette makes screen unreadable

| 16
| 16bit framebuffer
|

| 24
| 24bit framebuffer
| May result in a corrupted display

| 32
| 32bit framebuffer
| May need to be used in conjunction with `framebuffer_ignore_alpha=1`
|===

==== `framebuffer_ignore_alpha`

Set `framebuffer_ignore_alpha` to `1` to disable the alpha channel. Can help with the display of a 32bit `framebuffer_depth`.

==== `framebuffer_priority`

In a system with multiple displays, using the legacy (pre-KMS) graphics driver, this forces a specific internal display device to be the first Linux framebuffer (i.e. `/dev/fb0`).

The options that can be set are:

|===
| Display | ID

| Main LCD
| 0

| Secondary LCD
| 1

| HDMI 0
| 2

| Composite
| 3

| HDMI 1
| 7
|===

==== `max_framebuffers`

This configuration entry sets the maximum number of firmware framebuffers that can be created. Valid options are 0, 1, and 2. By default on devices before the Raspberry Pi 4 this is set to 1, so will need to be increased to 2 when using more than one display, for example HDMI and a DSI or DPI display. The Raspberry Pi 4 configuration sets this to 2 by default as it has two HDMI ports.

Generally in most cases it is safe to set this to 2, as framebuffers will only be created when an attached device is actually detected.

Setting this value to 0 can be used to reduce memory requirements when used in headless mode as it will prevent any framebuffers from being allocated.

==== `test_mode`

The `test_mode` command displays a test image and sound during boot (over the composite video and analogue audio outputs only) for the given number of seconds, before continuing to boot the OS as normal. This is used as a manufacturing test; the default value is `0`.

==== `display_hdmi_rotate`

Use `display_hdmi_rotate` to rotate or flip the HDMI display orientation. The default value is `0`.

|===
| display_hdmi_rotate | result

| 0
| no rotation

| 1
| rotate 90 degrees clockwise

| 2
| rotate 180 degrees clockwise

| 3
| rotate 270 degrees clockwise

| 0x10000
| horizontal flip

| 0x20000
| vertical flip
|===

Note that the 90 and 270 degree rotation options require additional memory on the GPU, so these will not work with the 16MB GPU split.

If using the VC4 FKMS V3D driver (this is the default on the Raspberry Pi 4), then 90 and 270 degree rotations are not supported. The Screen Configuration utility xref:configuration.adoc#rotating-your-display[provides display rotations] for this driver. 

==== `display_lcd_rotate`

For the legacy graphics driver (default on models prior to the Raspberry Pi 4), use `display_lcd_rotate` to rotate or flip the LCD orientation. Parameters are the same as `display_hdmi_rotate`. See also `lcd_rotate`.

==== `display_rotate`

`display_rotate` is deprecated in the latest firmware but has been retained for backwards compatibility. Please use `display_lcd_rotate` and `display_hdmi_rotate` instead.

Use `display_rotate` to rotate or flip the screen orientation. Parameters are the same as `display_hdmi_rotate`.

==== `disable_fw_kms_setup`

By default, the firmware parses the EDID of any HDMI attached display, picks an appropriate video mode, then passes the resolution and frame rate of the mode, along with overscan parameters, to the Linux kernel via settings on the kernel command line. In rare circumstances, this can have the effect of choosing a mode that is not in the EDID, and may be incompatible with the device. You can use `disable_fw_kms_setup=1` to disable the passing of these parameters and avoid this problem. The Linux video mode system (KMS) will then parse the EDID itself and pick an appropriate mode.

=== Other Options

==== `dispmanx_offline`

Forces `dispmanx` composition to be done offline in two offscreen framebuffers. This can allow more `dispmanx` elements to be composited, but is slower and may limit screen framerate to typically 30fps.
",12144,True,2500.7936224080513,median
"CLASS zcl_abapgit_repo_srv DEFINITION
  PUBLIC
  FINAL
  CREATE PRIVATE .

  PUBLIC SECTION.

    INTERFACES zif_abapgit_repo_srv .
    INTERFACES zif_abapgit_repo_listener .

    ALIASES get_repo_from_package
      FOR zif_abapgit_repo_srv~get_repo_from_package .

    ALIASES get_repo_from_url
      FOR zif_abapgit_repo_srv~get_repo_from_url .

    CLASS-METHODS get_instance
      RETURNING
        VALUE(ri_srv) TYPE REF TO zif_abapgit_repo_srv .
  PROTECTED SECTION.
  PRIVATE SECTION.

    ALIASES delete
      FOR zif_abapgit_repo_srv~delete .
    ALIASES get
      FOR zif_abapgit_repo_srv~get .
    ALIASES list
      FOR zif_abapgit_repo_srv~list .
    ALIASES validate_package
      FOR zif_abapgit_repo_srv~validate_package .
    ALIASES validate_url
      FOR zif_abapgit_repo_srv~validate_url .

    CLASS-DATA gi_ref TYPE REF TO zif_abapgit_repo_srv .
    DATA mv_init TYPE abap_bool VALUE abap_false ##NO_TEXT.
    DATA mt_list TYPE zif_abapgit_repo_srv=>ty_repo_list .

    METHODS determine_branch_name
      IMPORTING
        !iv_name       TYPE string
        !iv_url        TYPE string
      RETURNING
        VALUE(rv_name) TYPE string
      RAISING
        zcx_abapgit_exception .
    METHODS refresh
      RAISING
        zcx_abapgit_exception .
    METHODS instantiate_and_add
      IMPORTING
        !is_repo_meta  TYPE zif_abapgit_persistence=>ty_repo
      RETURNING
        VALUE(ro_repo) TYPE REF TO zcl_abapgit_repo
      RAISING
        zcx_abapgit_exception .
    METHODS add
      IMPORTING
        !io_repo TYPE REF TO zcl_abapgit_repo
      RAISING
        zcx_abapgit_exception .
    METHODS reinstantiate_repo
      IMPORTING
        !iv_key  TYPE zif_abapgit_persistence=>ty_repo-key
        !is_meta TYPE zif_abapgit_persistence=>ty_repo_xml
      RAISING
        zcx_abapgit_exception .
    METHODS validate_sub_super_packages
      IMPORTING
        !iv_package    TYPE devclass
        !it_repos      TYPE zif_abapgit_persistence=>ty_repos
        !iv_ign_subpkg TYPE abap_bool DEFAULT abap_false
      EXPORTING
        VALUE(eo_repo) TYPE REF TO zcl_abapgit_repo
        !ev_reason     TYPE string
      RAISING
        zcx_abapgit_exception .
ENDCLASS.



CLASS zcl_abapgit_repo_srv IMPLEMENTATION.


  METHOD add.

    DATA: lo_repo LIKE LINE OF mt_list.


    LOOP AT mt_list INTO lo_repo.
      IF lo_repo->ms_data-key = io_repo->ms_data-key.
        IF lo_repo = io_repo.
          RETURN.
        ENDIF.
        zcx_abapgit_exception=>raise( 'identical keys' ).
      ENDIF.
    ENDLOOP.

    io_repo->bind_listener( me ).
    APPEND io_repo TO mt_list.

  ENDMETHOD.


  METHOD determine_branch_name.

    DATA lo_branch_list TYPE REF TO zcl_abapgit_git_branch_list.

    rv_name = iv_name.
    IF rv_name IS INITIAL.
      ASSERT NOT iv_url IS INITIAL.
      lo_branch_list = zcl_abapgit_git_transport=>branches( iv_url ).
      rv_name = lo_branch_list->get_head_symref( ).
    ELSEIF -1 = find(
        val = rv_name
        sub = zif_abapgit_definitions=>c_git_branch-heads_prefix ).
      "" Assume short branch name was received
      rv_name = zif_abapgit_definitions=>c_git_branch-heads_prefix && rv_name.
    ENDIF.

  ENDMETHOD.


  METHOD get_instance.
    IF gi_ref IS INITIAL.
      CREATE OBJECT gi_ref TYPE zcl_abapgit_repo_srv.
    ENDIF.
    ri_srv = gi_ref.
  ENDMETHOD.


  METHOD instantiate_and_add.

    IF is_repo_meta-offline = abap_false.
      CREATE OBJECT ro_repo TYPE zcl_abapgit_repo_online
        EXPORTING
          is_data = is_repo_meta.
    ELSE.
      CREATE OBJECT ro_repo TYPE zcl_abapgit_repo_offline
        EXPORTING
          is_data = is_repo_meta.
    ENDIF.
    add( ro_repo ).

  ENDMETHOD.


  METHOD refresh.

    DATA: lt_list TYPE zif_abapgit_persistence=>ty_repos.

    FIELD-SYMBOLS: <ls_list> LIKE LINE OF lt_list.


    CLEAR mt_list.

    lt_list = zcl_abapgit_persist_factory=>get_repo( )->list( ).
    LOOP AT lt_list ASSIGNING <ls_list>.
      instantiate_and_add( <ls_list> ).
    ENDLOOP.

    mv_init = abap_true.

  ENDMETHOD.


  METHOD reinstantiate_repo.

    DATA lo_repo      TYPE REF TO zcl_abapgit_repo.
    DATA ls_full_meta TYPE zif_abapgit_persistence=>ty_repo.

    lo_repo = get( iv_key ).
    DELETE TABLE mt_list FROM lo_repo.
    ASSERT sy-subrc IS INITIAL.

    MOVE-CORRESPONDING is_meta TO ls_full_meta.
    ls_full_meta-key = iv_key.

    instantiate_and_add( ls_full_meta ).

  ENDMETHOD.


  METHOD validate_sub_super_packages.

    DATA:
      ls_repo     LIKE LINE OF it_repos,
      li_package  TYPE REF TO zif_abapgit_sap_package,
      lt_packages TYPE zif_abapgit_sap_package=>ty_devclass_tt,
      lo_repo     TYPE REF TO zcl_abapgit_repo.

    LOOP AT it_repos INTO ls_repo.
      lo_repo = get( ls_repo-key ).

      li_package = zcl_abapgit_factory=>get_sap_package( ls_repo-package ).
      IF li_package->exists( ) = abap_false.
        "" Skip dangling repository
        CONTINUE.
      ENDIF.

      CLEAR lt_packages.
      IF lo_repo->get_local_settings( )-ignore_subpackages = abap_false.
        APPEND LINES OF li_package->list_subpackages( ) TO lt_packages.
        READ TABLE lt_packages TRANSPORTING NO FIELDS
          WITH KEY table_line = iv_package.
        IF sy-subrc = 0.
          eo_repo = lo_repo.
          ev_reason = |Repository { lo_repo->get_name( ) } already contains { iv_package } |.
          RETURN.
        ENDIF.
      ENDIF.

      IF iv_ign_subpkg = abap_false.
        APPEND LINES OF li_package->list_superpackages( ) TO lt_packages.
        READ TABLE lt_packages TRANSPORTING NO FIELDS
          WITH KEY table_line = iv_package.
        IF sy-subrc = 0.
          eo_repo = lo_repo.
          ev_reason = |Repository { lo_repo->get_name( ) } already contains subpackage of { iv_package } |.
          RETURN.
        ENDIF.
      ENDIF.

    ENDLOOP.

  ENDMETHOD.


  METHOD zif_abapgit_repo_listener~on_meta_change.

    DATA li_persistence TYPE REF TO zif_abapgit_persist_repo.

    li_persistence = zcl_abapgit_persist_factory=>get_repo( ).
    li_persistence->update_metadata(
      iv_key         = iv_key
      is_meta        = is_meta
      is_change_mask = is_change_mask ).


    "" Recreate repo instance if type changed
    "" Instances in mt_list are of *_online and *_offline type
    "" If type is changed object should be recreated from the proper class
    "" TODO refactor, e.g. unify repo logic in one class
    IF is_change_mask-offline = abap_true.
      reinstantiate_repo(
        iv_key  = iv_key
        is_meta = is_meta ).

    ENDIF.

  ENDMETHOD.


  METHOD zif_abapgit_repo_srv~delete.

    zcl_abapgit_persist_factory=>get_repo( )->delete( io_repo->get_key( ) ).

    "" If favorite, remove it
    IF zcl_abapgit_persistence_user=>get_instance( )->is_favorite_repo( io_repo->get_key( ) ) = abap_true.
      zcl_abapgit_persistence_user=>get_instance( )->toggle_favorite( io_repo->get_key( ) ).
    ENDIF.

    DELETE TABLE mt_list FROM io_repo.
    ASSERT sy-subrc = 0.

  ENDMETHOD.


  METHOD zif_abapgit_repo_srv~get.

    FIELD-SYMBOLS: <lo_list> LIKE LINE OF mt_list.

    IF mv_init = abap_false.
      refresh( ).
    ENDIF.

    DO 2 TIMES.
      "" Repo might have been created in another session. Try again after refresh
      IF sy-index = 2.
        refresh( ).
      ENDIF.
      LOOP AT mt_list ASSIGNING <lo_list>.
        IF <lo_list>->ms_data-key = iv_key.
          ro_repo = <lo_list>.
          RETURN.
        ENDIF.
      ENDLOOP.
    ENDDO.

    zcx_abapgit_exception=>raise( 'repo not found, get' ).

  ENDMETHOD.


  METHOD zif_abapgit_repo_srv~get_repo_from_package.

    DATA:
      lt_repos TYPE zif_abapgit_persistence=>ty_repos,
      lv_name  TYPE zif_abapgit_persistence=>ty_local_settings-display_name,
      lv_owner TYPE zif_abapgit_persistence=>ty_local_settings-display_name.

    FIELD-SYMBOLS:
      <ls_repo> LIKE LINE OF lt_repos.

    "" check if package is already in use for a different repository
    lt_repos = zcl_abapgit_persist_factory=>get_repo( )->list( ).
    READ TABLE lt_repos WITH KEY package = iv_package ASSIGNING <ls_repo>.
    IF sy-subrc = 0.
      eo_repo = get_instance( )->get( <ls_repo>-key ).
      lv_name = eo_repo->get_name( ).
      lv_owner = <ls_repo>-created_by.
      ev_reason = |Package { iv_package } already versioned as { lv_name } by { lv_owner }|.
    ELSE.
      "" check if package is include as sub-package in a different repo
      validate_sub_super_packages(
        EXPORTING
          iv_package    = iv_package
          it_repos      = lt_repos
          iv_ign_subpkg = iv_ign_subpkg
        IMPORTING
          eo_repo       = eo_repo
          ev_reason     = ev_reason ).
    ENDIF.

  ENDMETHOD.


  METHOD zif_abapgit_repo_srv~get_repo_from_url.

    DATA:
      lt_repos                TYPE zif_abapgit_persistence=>ty_repos,
      lv_current_repo_address TYPE string,
      lv_check_repo_address   TYPE string,
      lv_repo_path            TYPE string,
      lv_name                 TYPE zif_abapgit_persistence=>ty_local_settings-display_name,
      lv_owner                TYPE zif_abapgit_persistence=>ty_local_settings-display_name.

    FIELD-SYMBOLS:
      <ls_repo> LIKE LINE OF lt_repos.

    CLEAR:
      eo_repo, ev_reason.

    lv_current_repo_address = zcl_abapgit_url=>url_address( iv_url ).

    "" check if url is already in use for a different package
    lt_repos = zcl_abapgit_persist_factory=>get_repo( )->list( ).
    LOOP AT lt_repos ASSIGNING <ls_repo> WHERE offline = abap_false.

      lv_check_repo_address = zcl_abapgit_url=>url_address( <ls_repo>-url ).

      IF lv_current_repo_address = lv_check_repo_address.
        eo_repo      = get_instance( )->get( <ls_repo>-key ).
        lv_repo_path = zcl_abapgit_url=>path_name( iv_url ).
        lv_name      = eo_repo->get_name( ).
        lv_owner     = <ls_repo>-created_by.
        ev_reason    = |Repository { lv_repo_path } already versioned as { lv_name } by { lv_owner }|.
        RETURN.
      ENDIF.

    ENDLOOP.

  ENDMETHOD.


  METHOD zif_abapgit_repo_srv~is_repo_installed.

    DATA: lt_repo        TYPE zif_abapgit_repo_srv=>ty_repo_list,
          lo_repo        TYPE REF TO zcl_abapgit_repo,
          lv_url         TYPE string,
          lv_package     TYPE devclass,
          lo_repo_online TYPE REF TO zcl_abapgit_repo_online,
          lv_err         TYPE string.

    lt_repo = list( ).

    LOOP AT lt_repo INTO lo_repo.
      CHECK lo_repo->is_offline( ) = abap_false.
      lo_repo_online ?= lo_repo.

      lv_url     = lo_repo_online->get_url( ).
      lv_package = lo_repo_online->get_package( ).
      CHECK to_upper( lv_url ) = to_upper( iv_url ).

      "" Validate bindings
      ""TODO refactor: move this message out of this method
      IF iv_target_package IS NOT INITIAL AND iv_target_package <> lv_package.
        lv_err = |Installation to package { lv_package } detected. |
              && |Cancelling installation|.
        zcx_abapgit_exception=>raise( lv_err ).
      ENDIF.

      rv_installed = abap_true.
      EXIT.
    ENDLOOP.

  ENDMETHOD.


  METHOD zif_abapgit_repo_srv~list.

    IF mv_init = abap_false.
      refresh( ).
    ENDIF.

    rt_list = mt_list.

  ENDMETHOD.


  METHOD zif_abapgit_repo_srv~new_offline.

    DATA: ls_repo        TYPE zif_abapgit_persistence=>ty_repo,
          lv_key         TYPE zif_abapgit_persistence=>ty_repo-key,
          lo_dot_abapgit TYPE REF TO zcl_abapgit_dot_abapgit.


    IF zcl_abapgit_auth=>is_allowed( zif_abapgit_auth=>gc_authorization-create_repo ) = abap_false.
      zcx_abapgit_exception=>raise( 'Not authorized' ).
    ENDIF.

    validate_package( iv_package ).

    IF iv_url IS INITIAL.
      zcx_abapgit_exception=>raise( 'Missing display name for repo' ).
    ENDIF.

    lo_dot_abapgit = zcl_abapgit_dot_abapgit=>build_default( ).
    lo_dot_abapgit->set_folder_logic( iv_folder_logic ).

    lv_key = zcl_abapgit_persist_factory=>get_repo( )->add(
      iv_url          = iv_url
      iv_branch_name  = ''
      iv_package      = iv_package
      iv_offline      = abap_true
      is_dot_abapgit  = lo_dot_abapgit->get_data( ) ).

    TRY.
        ls_repo = zcl_abapgit_persist_factory=>get_repo( )->read( lv_key ).
      CATCH zcx_abapgit_not_found.
        zcx_abapgit_exception=>raise( 'new_offline not found' ).
    ENDTRY.

    ro_repo ?= instantiate_and_add( ls_repo ).

    ls_repo-local_settings-serialize_master_lang_only = iv_master_lang_only.
    ro_repo->set_local_settings( ls_repo-local_settings ).

  ENDMETHOD.


  METHOD zif_abapgit_repo_srv~new_online.

    DATA: ls_repo        TYPE zif_abapgit_persistence=>ty_repo,
          lv_branch_name LIKE iv_branch_name,
          lv_key         TYPE zif_abapgit_persistence=>ty_repo-key,
          ls_dot_abapgit TYPE zif_abapgit_dot_abapgit=>ty_dot_abapgit,
          lv_url         TYPE string.


    ASSERT NOT iv_url IS INITIAL
      AND NOT iv_package IS INITIAL.

    lv_url = condense( iv_url ).

    IF zcl_abapgit_auth=>is_allowed( zif_abapgit_auth=>gc_authorization-create_repo ) = abap_false.
      zcx_abapgit_exception=>raise( 'Not authorized' ).
    ENDIF.

    validate_package( iv_package    = iv_package
                      iv_ign_subpkg = iv_ign_subpkg ).

    validate_url( lv_url ).

    lv_branch_name = determine_branch_name(
      iv_name = iv_branch_name
      iv_url  = lv_url ).

    ls_dot_abapgit = zcl_abapgit_dot_abapgit=>build_default( )->get_data( ).
    ls_dot_abapgit-folder_logic = iv_folder_logic.

    lv_key = zcl_abapgit_persist_factory=>get_repo( )->add(
      iv_url          = lv_url
      iv_branch_name  = lv_branch_name "" local !
      iv_display_name = iv_display_name
      iv_package      = iv_package
      iv_offline      = abap_false
      is_dot_abapgit  = ls_dot_abapgit ).
    TRY.
        ls_repo = zcl_abapgit_persist_factory=>get_repo( )->read( lv_key ).
      CATCH zcx_abapgit_not_found.
        zcx_abapgit_exception=>raise( 'new_online not found' ).
    ENDTRY.

    ro_repo ?= instantiate_and_add( ls_repo ).

    IF ls_repo-local_settings-ignore_subpackages <> iv_ign_subpkg.
      ls_repo-local_settings-ignore_subpackages = iv_ign_subpkg.
    ENDIF.
    ls_repo-local_settings-serialize_master_lang_only = iv_master_lang_only.
    ro_repo->set_local_settings( ls_repo-local_settings ).

    ro_repo->refresh( ).
    ro_repo->find_remote_dot_abapgit( ).

  ENDMETHOD.


  METHOD zif_abapgit_repo_srv~purge.

* uninstalls all objects, no UI or popups in this class

* todo, this should be a method on the repo instead?

    DATA: lt_tadir TYPE zif_abapgit_definitions=>ty_tadir_tt.
    DATA: lx_error TYPE REF TO zcx_abapgit_exception.

    ri_log = io_repo->create_new_log( 'Uninstall Log' ).

    IF io_repo->get_local_settings( )-write_protected = abap_true.
      zcx_abapgit_exception=>raise( 'Cannot purge. Local code is write-protected by repo config' ).
    ELSEIF zcl_abapgit_auth=>is_allowed( zif_abapgit_auth=>gc_authorization-uninstall ) = abap_false.
      zcx_abapgit_exception=>raise( 'Not authorized' ).
    ENDIF.

    lt_tadir = zcl_abapgit_factory=>get_tadir( )->read( io_repo->get_package( ) ).

    TRY.
        zcl_abapgit_objects=>delete( it_tadir  = lt_tadir
                                     is_checks = is_checks
                                     ii_log    = ri_log ).
      CATCH zcx_abapgit_exception INTO lx_error.
        "" If uninstall fails, repo needs a refresh to show which objects where deleted and which not
        io_repo->refresh( iv_drop_log = abap_false ).
        RAISE EXCEPTION lx_error.
    ENDTRY.

    delete( io_repo ).

  ENDMETHOD.


  METHOD zif_abapgit_repo_srv~validate_package.

    DATA: lv_as4user TYPE tdevc-as4user,
          lo_repo    TYPE REF TO zcl_abapgit_repo,
          lv_reason  TYPE string.

    IF iv_package IS INITIAL.
      zcx_abapgit_exception=>raise( 'add, package empty' ).
    ENDIF.

    IF iv_package = '$TMP'.
      zcx_abapgit_exception=>raise( 'not possible to use $TMP, create new (local) package' ).
    ENDIF.

    "" Check if package owned by SAP is allowed (new packages are ok, since they are created automatically)
    SELECT SINGLE as4user FROM tdevc
      INTO lv_as4user
      WHERE devclass = iv_package.                      ""#EC CI_GENBUFF
    IF sy-subrc = 0 AND lv_as4user = 'SAP' AND
      zcl_abapgit_factory=>get_environment( )->is_sap_object_allowed( ) = abap_false.
      zcx_abapgit_exception=>raise( |Package { iv_package } not allowed, responsible user = 'SAP'| ).
    ENDIF.

    "" Check if package is already used in another repo
    IF iv_chk_exists = abap_true.
      get_repo_from_package(
        EXPORTING
          iv_package    = iv_package
          iv_ign_subpkg = iv_ign_subpkg
        IMPORTING
          eo_repo       = lo_repo
          ev_reason     = lv_reason ).

      IF lo_repo IS BOUND.
        zcx_abapgit_exception=>raise( lv_reason ).
      ENDIF.
    ENDIF.

  ENDMETHOD.


  METHOD zif_abapgit_repo_srv~validate_url.

    DATA:
      lo_repo   TYPE REF TO zcl_abapgit_repo,
      lv_reason TYPE string.

    zcl_abapgit_url=>validate( iv_url ).

    IF iv_chk_exists = abap_true.
      get_repo_from_url(
        EXPORTING
          iv_url    = iv_url
        IMPORTING
          eo_repo   = lo_repo
          ev_reason = lv_reason ).
      IF lo_repo IS BOUND.
        zcx_abapgit_exception=>raise( lv_reason ).
      ENDIF.
    ENDIF.

  ENDMETHOD.
ENDCLASS.
",4600,False,1101.090920385058,median
"/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * 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 <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <memory>
#include <string>

#include ""atomic.h""
#include ""base/hex_dump.h""
#include ""base/logging.h""
#include ""base/macros.h""
#include ""base/stringprintf.h""
#include ""debugger.h""
#include ""jdwp/jdwp_constants.h""
#include ""jdwp/jdwp_event.h""
#include ""jdwp/jdwp_expand_buf.h""
#include ""jdwp/jdwp_priv.h""
#include ""runtime.h""
#include ""scoped_thread_state_change.h""
#include ""thread-inl.h""
#include ""utils.h""

namespace art {

namespace JDWP {

std::string DescribeField(const FieldId& field_id) {
  return StringPrintf(""%#"" PRIx64 "" (%s)"", field_id, Dbg::GetFieldName(field_id).c_str());
}

std::string DescribeMethod(const MethodId& method_id) {
  return StringPrintf(""%#"" PRIx64 "" (%s)"", method_id, Dbg::GetMethodName(method_id).c_str());
}

std::string DescribeRefTypeId(const RefTypeId& ref_type_id) {
  std::string signature(""unknown"");
  Dbg::GetSignature(ref_type_id, &signature);
  return StringPrintf(""%#"" PRIx64 "" (%s)"", ref_type_id, signature.c_str());
}

static JdwpError WriteTaggedObject(ExpandBuf* reply, ObjectId object_id)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  uint8_t tag;
  JdwpError rc = Dbg::GetObjectTag(object_id, &tag);
  if (rc == ERR_NONE) {
    expandBufAdd1(reply, tag);
    expandBufAddObjectId(reply, object_id);
  }
  return rc;
}

static JdwpError WriteTaggedObjectList(ExpandBuf* reply, const std::vector<ObjectId>& objects)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  expandBufAdd4BE(reply, objects.size());
  for (size_t i = 0; i < objects.size(); ++i) {
    JdwpError rc = WriteTaggedObject(reply, objects[i]);
    if (rc != ERR_NONE) {
      return rc;
    }
  }
  return ERR_NONE;
}

/*
 * Common code for *_InvokeMethod requests.
 *
 * If ""is_constructor"" is set, this returns ""object_id"" rather than the
 * expected-to-be-void return value of the called function.
 */
static JdwpError RequestInvoke(JdwpState*, Request* request,
                               ObjectId thread_id, ObjectId object_id,
                               RefTypeId class_id, MethodId method_id, bool is_constructor)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  CHECK(!is_constructor || object_id != 0);

  int32_t arg_count = request->ReadSigned32(""argument count"");

  VLOG(jdwp) << StringPrintf(""    --> thread_id=%#"" PRIx64 "" object_id=%#"" PRIx64,
                             thread_id, object_id);
  VLOG(jdwp) << StringPrintf(""        class_id=%#"" PRIx64 "" method_id=%#"" PRIx64 "" %s.%s"",
                             class_id, method_id, Dbg::GetClassName(class_id).c_str(),
                             Dbg::GetMethodName(method_id).c_str());
  VLOG(jdwp) << StringPrintf(""        %d args:"", arg_count);

  std::unique_ptr<JdwpTag[]> argTypes(arg_count > 0 ? new JdwpTag[arg_count] : nullptr);
  std::unique_ptr<uint64_t[]> argValues(arg_count > 0 ? new uint64_t[arg_count] : nullptr);
  for (int32_t i = 0; i < arg_count; ++i) {
    argTypes[i] = request->ReadTag();
    size_t width = Dbg::GetTagWidth(argTypes[i]);
    argValues[i] = request->ReadValue(width);
    VLOG(jdwp) << ""          "" << argTypes[i] << StringPrintf(""(%zd): %#"" PRIx64, width,
                                                              argValues[i]);
  }

  uint32_t options = request->ReadUnsigned32(""InvokeOptions bit flags"");
  VLOG(jdwp) << StringPrintf(""        options=0x%04x%s%s"", options,
                             (options & INVOKE_SINGLE_THREADED) ? "" (SINGLE_THREADED)"" : """",
                             (options & INVOKE_NONVIRTUAL) ? "" (NONVIRTUAL)"" : """");

  JDWP::JdwpError error =  Dbg::PrepareInvokeMethod(request->GetId(), thread_id, object_id,
                                                    class_id, method_id, arg_count,
                                                    argValues.get(), argTypes.get(), options);
  if (error == JDWP::ERR_NONE) {
    // We successfully requested the invoke. The event thread now owns the arguments array in its
    // DebugInvokeReq mailbox.
    argValues.release();
  }
  return error;
}

static JdwpError VM_Version(JdwpState*, Request*, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  // Text information on runtime version.
  std::string version(StringPrintf(""Android Runtime %s"", Runtime::Current()->GetVersion()));
  expandBufAddUtf8String(pReply, version);

  // JDWP version numbers, major and minor.
  expandBufAdd4BE(pReply, 1);
  expandBufAdd4BE(pReply, 6);

  // ""java.version"".
  expandBufAddUtf8String(pReply, ""1.6.0"");

  // ""java.vm.name"".
  expandBufAddUtf8String(pReply, ""Dalvik"");

  return ERR_NONE;
}

/*
 * Given a class JNI signature (e.g. ""Ljava/lang/Error;""), return the
 * referenceTypeID.  We need to send back more than one if the class has
 * been loaded by multiple class loaders.
 */
static JdwpError VM_ClassesBySignature(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  std::string classDescriptor(request->ReadUtf8String());

  std::vector<RefTypeId> ids;
  Dbg::FindLoadedClassBySignature(classDescriptor.c_str(), &ids);

  expandBufAdd4BE(pReply, ids.size());

  for (size_t i = 0; i < ids.size(); ++i) {
    // Get class vs. interface and status flags.
    JDWP::JdwpTypeTag type_tag;
    uint32_t class_status;
    JDWP::JdwpError status = Dbg::GetClassInfo(ids[i], &type_tag, &class_status, nullptr);
    if (status != ERR_NONE) {
      return status;
    }

    expandBufAdd1(pReply, type_tag);
    expandBufAddRefTypeId(pReply, ids[i]);
    expandBufAdd4BE(pReply, class_status);
  }

  return ERR_NONE;
}

/*
 * Handle request for the thread IDs of all running threads.
 *
 * We exclude ourselves from the list, because we don't allow ourselves
 * to be suspended, and that violates some JDWP expectations.
 */
static JdwpError VM_AllThreads(JdwpState*, Request*, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  std::vector<ObjectId> thread_ids;
  Dbg::GetThreads(nullptr /* all thread groups */, &thread_ids);

  expandBufAdd4BE(pReply, thread_ids.size());
  for (uint32_t i = 0; i < thread_ids.size(); ++i) {
    expandBufAddObjectId(pReply, thread_ids[i]);
  }

  return ERR_NONE;
}

/*
 * List all thread groups that do not have a parent.
 */
static JdwpError VM_TopLevelThreadGroups(JdwpState*, Request*, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  /*
   * TODO: maintain a list of parentless thread groups in the VM.
   *
   * For now, just return ""system"".  Application threads are created
   * in ""main"", which is a child of ""system"".
   */
  uint32_t groups = 1;
  expandBufAdd4BE(pReply, groups);
  ObjectId thread_group_id = Dbg::GetSystemThreadGroupId();
  expandBufAddObjectId(pReply, thread_group_id);

  return ERR_NONE;
}

/*
 * Respond with the sizes of the basic debugger types.
 */
static JdwpError VM_IDSizes(JdwpState*, Request*, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  expandBufAdd4BE(pReply, sizeof(FieldId));
  expandBufAdd4BE(pReply, sizeof(MethodId));
  expandBufAdd4BE(pReply, sizeof(ObjectId));
  expandBufAdd4BE(pReply, sizeof(RefTypeId));
  expandBufAdd4BE(pReply, sizeof(FrameId));
  return ERR_NONE;
}

static JdwpError VM_Dispose(JdwpState*, Request*, ExpandBuf*)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  Dbg::Dispose();
  return ERR_NONE;
}

/*
 * Suspend the execution of the application running in the VM (i.e. suspend
 * all threads).
 *
 * This needs to increment the ""suspend count"" on all threads.
 */
static JdwpError VM_Suspend(JdwpState*, Request*, ExpandBuf*)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  Thread* self = Thread::Current();
  ScopedThreadSuspension sts(self, kWaitingForDebuggerSuspension);
  Dbg::SuspendVM();
  return ERR_NONE;
}

/*
 * Resume execution.  Decrements the ""suspend count"" of all threads.
 */
static JdwpError VM_Resume(JdwpState*, Request*, ExpandBuf*)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  Dbg::ResumeVM();
  return ERR_NONE;
}

static JdwpError VM_Exit(JdwpState* state, Request* request, ExpandBuf*)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  uint32_t exit_status = request->ReadUnsigned32(""exit_status"");
  state->ExitAfterReplying(exit_status);
  return ERR_NONE;
}

/*
 * Create a new string in the VM and return its ID.
 *
 * (Ctrl-Shift-I in Eclipse on an array of objects causes it to create the
 * string ""java.util.Arrays"".)
 */
static JdwpError VM_CreateString(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  std::string str(request->ReadUtf8String());
  ObjectId string_id;
  JdwpError status = Dbg::CreateString(str, &string_id);
  if (status != ERR_NONE) {
    return status;
  }
  expandBufAddObjectId(pReply, string_id);
  return ERR_NONE;
}

static JdwpError VM_ClassPaths(JdwpState*, Request*, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  expandBufAddUtf8String(pReply, ""/"");

  std::vector<std::string> class_path;
  Split(Runtime::Current()->GetClassPathString(), ':', &class_path);
  expandBufAdd4BE(pReply, class_path.size());
  for (const std::string& str : class_path) {
    expandBufAddUtf8String(pReply, str);
  }

  std::vector<std::string> boot_class_path;
  Split(Runtime::Current()->GetBootClassPathString(), ':', &boot_class_path);
  expandBufAdd4BE(pReply, boot_class_path.size());
  for (const std::string& str : boot_class_path) {
    expandBufAddUtf8String(pReply, str);
  }

  return ERR_NONE;
}

static JdwpError VM_DisposeObjects(JdwpState*, Request* request, ExpandBuf*)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  size_t object_count = request->ReadUnsigned32(""object_count"");
  for (size_t i = 0; i < object_count; ++i) {
    ObjectId object_id = request->ReadObjectId();
    uint32_t reference_count = request->ReadUnsigned32(""reference_count"");
    Dbg::DisposeObject(object_id, reference_count);
  }
  return ERR_NONE;
}

static JdwpError VM_Capabilities(JdwpState*, Request*, ExpandBuf* reply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  expandBufAdd1(reply, true);    // canWatchFieldModification
  expandBufAdd1(reply, true);    // canWatchFieldAccess
  expandBufAdd1(reply, true);    // canGetBytecodes
  expandBufAdd1(reply, true);    // canGetSyntheticAttribute
  expandBufAdd1(reply, true);    // canGetOwnedMonitorInfo
  expandBufAdd1(reply, true);    // canGetCurrentContendedMonitor
  expandBufAdd1(reply, true);    // canGetMonitorInfo
  return ERR_NONE;
}

static JdwpError VM_CapabilitiesNew(JdwpState*, Request* request, ExpandBuf* reply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  // The first few capabilities are the same as those reported by the older call.
  VM_Capabilities(nullptr, request, reply);

  expandBufAdd1(reply, false);   // canRedefineClasses
  expandBufAdd1(reply, false);   // canAddMethod
  expandBufAdd1(reply, false);   // canUnrestrictedlyRedefineClasses
  expandBufAdd1(reply, false);   // canPopFrames
  expandBufAdd1(reply, true);    // canUseInstanceFilters
  expandBufAdd1(reply, false);   // canGetSourceDebugExtension
  expandBufAdd1(reply, false);   // canRequestVMDeathEvent
  expandBufAdd1(reply, false);   // canSetDefaultStratum
  expandBufAdd1(reply, true);    // 1.6: canGetInstanceInfo
  expandBufAdd1(reply, false);   // 1.6: canRequestMonitorEvents
  expandBufAdd1(reply, true);    // 1.6: canGetMonitorFrameInfo
  expandBufAdd1(reply, false);   // 1.6: canUseSourceNameFilters
  expandBufAdd1(reply, false);   // 1.6: canGetConstantPool
  expandBufAdd1(reply, false);   // 1.6: canForceEarlyReturn

  // Fill in reserved22 through reserved32; note count started at 1.
  for (size_t i = 22; i <= 32; ++i) {
    expandBufAdd1(reply, false);
  }
  return ERR_NONE;
}

static JdwpError VM_AllClassesImpl(ExpandBuf* pReply, bool descriptor_and_status, bool generic)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  std::vector<JDWP::RefTypeId> classes;
  Dbg::GetClassList(&classes);

  expandBufAdd4BE(pReply, classes.size());

  for (size_t i = 0; i < classes.size(); ++i) {
    static const char genericSignature[1] = """";
    JDWP::JdwpTypeTag type_tag;
    std::string descriptor;
    uint32_t class_status;
    JDWP::JdwpError status = Dbg::GetClassInfo(classes[i], &type_tag, &class_status, &descriptor);
    if (status != ERR_NONE) {
      return status;
    }

    expandBufAdd1(pReply, type_tag);
    expandBufAddRefTypeId(pReply, classes[i]);
    if (descriptor_and_status) {
      expandBufAddUtf8String(pReply, descriptor);
      if (generic) {
        expandBufAddUtf8String(pReply, genericSignature);
      }
      expandBufAdd4BE(pReply, class_status);
    }
  }

  return ERR_NONE;
}

static JdwpError VM_AllClasses(JdwpState*, Request*, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  return VM_AllClassesImpl(pReply, true, false);
}

static JdwpError VM_AllClassesWithGeneric(JdwpState*, Request*, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  return VM_AllClassesImpl(pReply, true, true);
}

static JdwpError VM_InstanceCounts(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  int32_t class_count = request->ReadSigned32(""class count"");
  if (class_count < 0) {
    return ERR_ILLEGAL_ARGUMENT;
  }
  std::vector<RefTypeId> class_ids;
  for (int32_t i = 0; i < class_count; ++i) {
    class_ids.push_back(request->ReadRefTypeId());
  }

  std::vector<uint64_t> counts;
  JdwpError rc = Dbg::GetInstanceCounts(class_ids, &counts);
  if (rc != ERR_NONE) {
    return rc;
  }

  expandBufAdd4BE(pReply, counts.size());
  for (size_t i = 0; i < counts.size(); ++i) {
    expandBufAdd8BE(pReply, counts[i]);
  }
  return ERR_NONE;
}

static JdwpError RT_Modifiers(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId refTypeId = request->ReadRefTypeId();
  return Dbg::GetModifiers(refTypeId, pReply);
}

/*
 * Get values from static fields in a reference type.
 */
static JdwpError RT_GetValues(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId refTypeId = request->ReadRefTypeId();
  int32_t field_count = request->ReadSigned32(""field count"");
  expandBufAdd4BE(pReply, field_count);
  for (int32_t i = 0; i < field_count; ++i) {
    FieldId fieldId = request->ReadFieldId();
    JdwpError status = Dbg::GetStaticFieldValue(refTypeId, fieldId, pReply);
    if (status != ERR_NONE) {
      return status;
    }
  }
  return ERR_NONE;
}

/*
 * Get the name of the source file in which a reference type was declared.
 */
static JdwpError RT_SourceFile(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId refTypeId = request->ReadRefTypeId();
  std::string source_file;
  JdwpError status = Dbg::GetSourceFile(refTypeId, &source_file);
  if (status != ERR_NONE) {
    return status;
  }
  expandBufAddUtf8String(pReply, source_file);
  return ERR_NONE;
}

/*
 * Return the current status of the reference type.
 */
static JdwpError RT_Status(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId refTypeId = request->ReadRefTypeId();
  JDWP::JdwpTypeTag type_tag;
  uint32_t class_status;
  JDWP::JdwpError status = Dbg::GetClassInfo(refTypeId, &type_tag, &class_status, nullptr);
  if (status != ERR_NONE) {
    return status;
  }
  expandBufAdd4BE(pReply, class_status);
  return ERR_NONE;
}

/*
 * Return interfaces implemented directly by this class.
 */
static JdwpError RT_Interfaces(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId refTypeId = request->ReadRefTypeId();
  return Dbg::OutputDeclaredInterfaces(refTypeId, pReply);
}

/*
 * Return the class object corresponding to this type.
 */
static JdwpError RT_ClassObject(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId refTypeId = request->ReadRefTypeId();
  ObjectId class_object_id;
  JdwpError status = Dbg::GetClassObject(refTypeId, &class_object_id);
  if (status != ERR_NONE) {
    return status;
  }
  VLOG(jdwp) << StringPrintf(""    --> ObjectId %#"" PRIx64, class_object_id);
  expandBufAddObjectId(pReply, class_object_id);
  return ERR_NONE;
}

/*
 * Returns the value of the SourceDebugExtension attribute.
 *
 * JDB seems interested, but DEX files don't currently support this.
 */
static JdwpError RT_SourceDebugExtension(JdwpState*, Request*, ExpandBuf*)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  /* referenceTypeId in, string out */
  return ERR_ABSENT_INFORMATION;
}

static JdwpError RT_Signature(JdwpState*, Request* request, ExpandBuf* pReply, bool with_generic)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId refTypeId = request->ReadRefTypeId();

  std::string signature;
  JdwpError status = Dbg::GetSignature(refTypeId, &signature);
  if (status != ERR_NONE) {
    return status;
  }
  expandBufAddUtf8String(pReply, signature);
  if (with_generic) {
    expandBufAddUtf8String(pReply, """");
  }
  return ERR_NONE;
}

static JdwpError RT_Signature(JdwpState* state, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  return RT_Signature(state, request, pReply, false);
}

static JdwpError RT_SignatureWithGeneric(JdwpState* state, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  return RT_Signature(state, request, pReply, true);
}

/*
 * Return the instance of java.lang.ClassLoader that loaded the specified
 * reference type, or null if it was loaded by the system loader.
 */
static JdwpError RT_ClassLoader(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId refTypeId = request->ReadRefTypeId();
  return Dbg::GetClassLoader(refTypeId, pReply);
}

/*
 * Given a referenceTypeId, return a block of stuff that describes the
 * fields declared by a class.
 */
static JdwpError RT_FieldsWithGeneric(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId refTypeId = request->ReadRefTypeId();
  return Dbg::OutputDeclaredFields(refTypeId, true, pReply);
}

// Obsolete equivalent of FieldsWithGeneric, without the generic type information.
static JdwpError RT_Fields(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId refTypeId = request->ReadRefTypeId();
  return Dbg::OutputDeclaredFields(refTypeId, false, pReply);
}

/*
 * Given a referenceTypeID, return a block of goodies describing the
 * methods declared by a class.
 */
static JdwpError RT_MethodsWithGeneric(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId refTypeId = request->ReadRefTypeId();
  return Dbg::OutputDeclaredMethods(refTypeId, true, pReply);
}

// Obsolete equivalent of MethodsWithGeneric, without the generic type information.
static JdwpError RT_Methods(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId refTypeId = request->ReadRefTypeId();
  return Dbg::OutputDeclaredMethods(refTypeId, false, pReply);
}

static JdwpError RT_Instances(JdwpState*, Request* request, ExpandBuf* reply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId class_id = request->ReadRefTypeId();
  int32_t max_count = request->ReadSigned32(""max count"");
  if (max_count < 0) {
    return ERR_ILLEGAL_ARGUMENT;
  }

  std::vector<ObjectId> instances;
  JdwpError rc = Dbg::GetInstances(class_id, max_count, &instances);
  if (rc != ERR_NONE) {
    return rc;
  }

  return WriteTaggedObjectList(reply, instances);
}

/*
 * Return the immediate superclass of a class.
 */
static JdwpError CT_Superclass(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId class_id = request->ReadRefTypeId();
  RefTypeId superClassId;
  JdwpError status = Dbg::GetSuperclass(class_id, &superClassId);
  if (status != ERR_NONE) {
    return status;
  }
  expandBufAddRefTypeId(pReply, superClassId);
  return ERR_NONE;
}

/*
 * Set static class values.
 */
static JdwpError CT_SetValues(JdwpState* , Request* request, ExpandBuf*)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId class_id = request->ReadRefTypeId();
  int32_t values_count = request->ReadSigned32(""values count"");

  UNUSED(class_id);

  for (int32_t i = 0; i < values_count; ++i) {
    FieldId fieldId = request->ReadFieldId();
    JDWP::JdwpTag fieldTag = Dbg::GetStaticFieldBasicTag(fieldId);
    size_t width = Dbg::GetTagWidth(fieldTag);
    uint64_t value = request->ReadValue(width);

    VLOG(jdwp) << ""    --> field="" << fieldId << "" tag="" << fieldTag << "" --> "" << value;
    JdwpError status = Dbg::SetStaticFieldValue(fieldId, value, width);
    if (status != ERR_NONE) {
      return status;
    }
  }

  return ERR_NONE;
}

/*
 * Invoke a static method.
 *
 * Example: Eclipse sometimes uses java/lang/Class.forName(String s) on
 * values in the ""variables"" display.
 */
static JdwpError CT_InvokeMethod(JdwpState* state, Request* request,
                                 ExpandBuf* pReply ATTRIBUTE_UNUSED)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId class_id = request->ReadRefTypeId();
  ObjectId thread_id = request->ReadThreadId();
  MethodId method_id = request->ReadMethodId();

  return RequestInvoke(state, request, thread_id, 0, class_id, method_id, false);
}

/*
 * Create a new object of the requested type, and invoke the specified
 * constructor.
 *
 * Example: in IntelliJ, create a watch on ""new String(myByteArray)"" to
 * see the contents of a byte[] as a string.
 */
static JdwpError CT_NewInstance(JdwpState* state, Request* request,
                                ExpandBuf* pReply ATTRIBUTE_UNUSED)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId class_id = request->ReadRefTypeId();
  ObjectId thread_id = request->ReadThreadId();
  MethodId method_id = request->ReadMethodId();

  ObjectId object_id;
  JdwpError status = Dbg::CreateObject(class_id, &object_id);
  if (status != ERR_NONE) {
    return status;
  }
  return RequestInvoke(state, request, thread_id, object_id, class_id, method_id, true);
}

/*
 * Create a new array object of the requested type and length.
 */
static JdwpError AT_newInstance(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId arrayTypeId = request->ReadRefTypeId();
  int32_t length = request->ReadSigned32(""length"");

  ObjectId object_id;
  JdwpError status = Dbg::CreateArrayObject(arrayTypeId, length, &object_id);
  if (status != ERR_NONE) {
    return status;
  }
  expandBufAdd1(pReply, JT_ARRAY);
  expandBufAddObjectId(pReply, object_id);
  return ERR_NONE;
}

/*
 * Invoke a static method on an interface.
 */
static JdwpError IT_InvokeMethod(JdwpState* state, Request* request,
                                 ExpandBuf* pReply ATTRIBUTE_UNUSED)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId class_id = request->ReadRefTypeId();
  ObjectId thread_id = request->ReadThreadId();
  MethodId method_id = request->ReadMethodId();

  return RequestInvoke(state, request, thread_id, 0, class_id, method_id, false);
}

/*
 * Return line number information for the method, if present.
 */
static JdwpError M_LineTable(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId refTypeId = request->ReadRefTypeId();
  MethodId method_id = request->ReadMethodId();

  Dbg::OutputLineTable(refTypeId, method_id, pReply);

  return ERR_NONE;
}

static JdwpError M_VariableTable(JdwpState*, Request* request, ExpandBuf* pReply,
                                 bool generic)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId class_id = request->ReadRefTypeId();
  MethodId method_id = request->ReadMethodId();

  // We could return ERR_ABSENT_INFORMATION here if the DEX file was built without local variable
  // information. That will cause Eclipse to make a best-effort attempt at displaying local
  // variables anonymously. However, the attempt isn't very good, so we're probably better off just
  // not showing anything.
  Dbg::OutputVariableTable(class_id, method_id, generic, pReply);
  return ERR_NONE;
}

static JdwpError M_VariableTable(JdwpState* state, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  return M_VariableTable(state, request, pReply, false);
}

static JdwpError M_VariableTableWithGeneric(JdwpState* state, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  return M_VariableTable(state, request, pReply, true);
}

static JdwpError M_Bytecodes(JdwpState*, Request* request, ExpandBuf* reply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId class_id = request->ReadRefTypeId();
  MethodId method_id = request->ReadMethodId();

  std::vector<uint8_t> bytecodes;
  JdwpError rc = Dbg::GetBytecodes(class_id, method_id, &bytecodes);
  if (rc != ERR_NONE) {
    return rc;
  }

  expandBufAdd4BE(reply, bytecodes.size());
  for (size_t i = 0; i < bytecodes.size(); ++i) {
    expandBufAdd1(reply, bytecodes[i]);
  }

  return ERR_NONE;
}

// Default implementation for IDEs relying on this command.
static JdwpError M_IsObsolete(JdwpState*, Request* request, ExpandBuf* reply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  request->ReadRefTypeId();  // unused reference type ID
  request->ReadMethodId();   // unused method ID
  expandBufAdd1(reply, false);  // a method is never obsolete.
  return ERR_NONE;
}

/*
 * Given an object reference, return the runtime type of the object
 * (class or array).
 *
 * This can get called on different things, e.g. thread_id gets
 * passed in here.
 */
static JdwpError OR_ReferenceType(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId object_id = request->ReadObjectId();
  return Dbg::GetReferenceType(object_id, pReply);
}

/*
 * Get values from the fields of an object.
 */
static JdwpError OR_GetValues(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId object_id = request->ReadObjectId();
  int32_t field_count = request->ReadSigned32(""field count"");

  expandBufAdd4BE(pReply, field_count);
  for (int32_t i = 0; i < field_count; ++i) {
    FieldId fieldId = request->ReadFieldId();
    JdwpError status = Dbg::GetFieldValue(object_id, fieldId, pReply);
    if (status != ERR_NONE) {
      return status;
    }
  }

  return ERR_NONE;
}

/*
 * Set values in the fields of an object.
 */
static JdwpError OR_SetValues(JdwpState*, Request* request, ExpandBuf*)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId object_id = request->ReadObjectId();
  int32_t field_count = request->ReadSigned32(""field count"");

  for (int32_t i = 0; i < field_count; ++i) {
    FieldId fieldId = request->ReadFieldId();

    JDWP::JdwpTag fieldTag = Dbg::GetFieldBasicTag(fieldId);
    size_t width = Dbg::GetTagWidth(fieldTag);
    uint64_t value = request->ReadValue(width);

    VLOG(jdwp) << ""    --> fieldId="" << fieldId << "" tag="" << fieldTag << ""("" << width << "") value="" << value;
    JdwpError status = Dbg::SetFieldValue(object_id, fieldId, value, width);
    if (status != ERR_NONE) {
      return status;
    }
  }

  return ERR_NONE;
}

static JdwpError OR_MonitorInfo(JdwpState*, Request* request, ExpandBuf* reply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId object_id = request->ReadObjectId();
  return Dbg::GetMonitorInfo(object_id, reply);
}

/*
 * Invoke an instance method.  The invocation must occur in the specified
 * thread, which must have been suspended by an event.
 *
 * The call is synchronous.  All threads in the VM are resumed, unless the
 * SINGLE_THREADED flag is set.
 *
 * If you ask Eclipse to ""inspect"" an object (or ask JDB to ""print"" an
 * object), it will try to invoke the object's toString() function.  This
 * feature becomes crucial when examining ArrayLists with Eclipse.
 */
static JdwpError OR_InvokeMethod(JdwpState* state, Request* request,
                                 ExpandBuf* pReply ATTRIBUTE_UNUSED)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId object_id = request->ReadObjectId();
  ObjectId thread_id = request->ReadThreadId();
  RefTypeId class_id = request->ReadRefTypeId();
  MethodId method_id = request->ReadMethodId();

  return RequestInvoke(state, request, thread_id, object_id, class_id, method_id, false);
}

static JdwpError OR_DisableCollection(JdwpState*, Request* request, ExpandBuf*)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId object_id = request->ReadObjectId();
  return Dbg::DisableCollection(object_id);
}

static JdwpError OR_EnableCollection(JdwpState*, Request* request, ExpandBuf*)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId object_id = request->ReadObjectId();
  return Dbg::EnableCollection(object_id);
}

static JdwpError OR_IsCollected(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId object_id = request->ReadObjectId();
  bool is_collected;
  JdwpError rc = Dbg::IsCollected(object_id, &is_collected);
  expandBufAdd1(pReply, is_collected ? 1 : 0);
  return rc;
}

static JdwpError OR_ReferringObjects(JdwpState*, Request* request, ExpandBuf* reply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId object_id = request->ReadObjectId();
  int32_t max_count = request->ReadSigned32(""max count"");
  if (max_count < 0) {
    return ERR_ILLEGAL_ARGUMENT;
  }

  std::vector<ObjectId> referring_objects;
  JdwpError rc = Dbg::GetReferringObjects(object_id, max_count, &referring_objects);
  if (rc != ERR_NONE) {
    return rc;
  }

  return WriteTaggedObjectList(reply, referring_objects);
}

/*
 * Return the string value in a string object.
 */
static JdwpError SR_Value(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId stringObject = request->ReadObjectId();
  std::string str;
  JDWP::JdwpError error = Dbg::StringToUtf8(stringObject, &str);
  if (error != JDWP::ERR_NONE) {
    return error;
  }

  VLOG(jdwp) << StringPrintf(""    --> %s"", PrintableString(str.c_str()).c_str());

  expandBufAddUtf8String(pReply, str);

  return ERR_NONE;
}

/*
 * Return a thread's name.
 */
static JdwpError TR_Name(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId thread_id = request->ReadThreadId();

  std::string name;
  JdwpError error = Dbg::GetThreadName(thread_id, &name);
  if (error != ERR_NONE) {
    return error;
  }
  VLOG(jdwp) << StringPrintf(""  Name of thread %#"" PRIx64 "" is \\""%s\\"""", thread_id, name.c_str());
  expandBufAddUtf8String(pReply, name);

  return ERR_NONE;
}

/*
 * Suspend the specified thread.
 *
 * It's supposed to remain suspended even if interpreted code wants to
 * resume it; only the JDI is allowed to resume it.
 */
static JdwpError TR_Suspend(JdwpState*, Request* request, ExpandBuf*)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId thread_id = request->ReadThreadId();

  if (thread_id == Dbg::GetThreadSelfId()) {
    LOG(INFO) << ""  Warning: ignoring request to suspend self"";
    return ERR_THREAD_NOT_SUSPENDED;
  }

  Thread* self = Thread::Current();
  ScopedThreadSuspension sts(self, kWaitingForDebuggerSend);
  JdwpError result = Dbg::SuspendThread(thread_id);
  return result;
}

/*
 * Resume the specified thread.
 */
static JdwpError TR_Resume(JdwpState*, Request* request, ExpandBuf*)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId thread_id = request->ReadThreadId();

  if (thread_id == Dbg::GetThreadSelfId()) {
    LOG(INFO) << ""  Warning: ignoring request to resume self"";
    return ERR_NONE;
  }

  Dbg::ResumeThread(thread_id);
  return ERR_NONE;
}

/*
 * Return status of specified thread.
 */
static JdwpError TR_Status(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId thread_id = request->ReadThreadId();

  JDWP::JdwpThreadStatus threadStatus;
  JDWP::JdwpSuspendStatus suspendStatus;
  JdwpError error = Dbg::GetThreadStatus(thread_id, &threadStatus, &suspendStatus);
  if (error != ERR_NONE) {
    return error;
  }

  VLOG(jdwp) << ""    --> "" << threadStatus << "", "" << suspendStatus;

  expandBufAdd4BE(pReply, threadStatus);
  expandBufAdd4BE(pReply, suspendStatus);

  return ERR_NONE;
}

/*
 * Return the thread group that the specified thread is a member of.
 */
static JdwpError TR_ThreadGroup(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId thread_id = request->ReadThreadId();
  return Dbg::GetThreadGroup(thread_id, pReply);
}

/*
 * Return the current call stack of a suspended thread.
 *
 * If the thread isn't suspended, the error code isn't defined, but should
 * be THREAD_NOT_SUSPENDED.
 */
static JdwpError TR_Frames(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId thread_id = request->ReadThreadId();
  uint32_t start_frame = request->ReadUnsigned32(""start frame"");
  uint32_t length = request->ReadUnsigned32(""length"");

  size_t actual_frame_count;
  JdwpError error = Dbg::GetThreadFrameCount(thread_id, &actual_frame_count);
  if (error != ERR_NONE) {
    return error;
  }

  if (actual_frame_count <= 0) {
    return ERR_THREAD_NOT_SUSPENDED;  // 0 means no managed frames (which means ""in native"").
  }

  if (start_frame > actual_frame_count) {
    return ERR_INVALID_INDEX;
  }
  if (length == static_cast<uint32_t>(-1)) {
    length = actual_frame_count - start_frame;
  }
  if (start_frame + length > actual_frame_count) {
    return ERR_INVALID_LENGTH;
  }

  return Dbg::GetThreadFrames(thread_id, start_frame, length, pReply);
}

/*
 * Returns the #of frames on the specified thread, which must be suspended.
 */
static JdwpError TR_FrameCount(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId thread_id = request->ReadThreadId();

  size_t frame_count;
  JdwpError rc = Dbg::GetThreadFrameCount(thread_id, &frame_count);
  if (rc != ERR_NONE) {
    return rc;
  }
  expandBufAdd4BE(pReply, static_cast<uint32_t>(frame_count));

  return ERR_NONE;
}

static JdwpError TR_OwnedMonitors(Request* request, ExpandBuf* reply, bool with_stack_depths)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId thread_id = request->ReadThreadId();

  std::vector<ObjectId> monitors;
  std::vector<uint32_t> stack_depths;
  JdwpError rc = Dbg::GetOwnedMonitors(thread_id, &monitors, &stack_depths);
  if (rc != ERR_NONE) {
    return rc;
  }

  expandBufAdd4BE(reply, monitors.size());
  for (size_t i = 0; i < monitors.size(); ++i) {
    rc = WriteTaggedObject(reply, monitors[i]);
    if (rc != ERR_NONE) {
      return rc;
    }
    if (with_stack_depths) {
      expandBufAdd4BE(reply, stack_depths[i]);
    }
  }
  return ERR_NONE;
}

static JdwpError TR_OwnedMonitors(JdwpState*, Request* request, ExpandBuf* reply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  return TR_OwnedMonitors(request, reply, false);
}

static JdwpError TR_OwnedMonitorsStackDepthInfo(JdwpState*, Request* request, ExpandBuf* reply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  return TR_OwnedMonitors(request, reply, true);
}

static JdwpError TR_CurrentContendedMonitor(JdwpState*, Request* request, ExpandBuf* reply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId thread_id = request->ReadThreadId();

  ObjectId contended_monitor;
  JdwpError rc = Dbg::GetContendedMonitor(thread_id, &contended_monitor);
  if (rc != ERR_NONE) {
    return rc;
  }
  return WriteTaggedObject(reply, contended_monitor);
}

static JdwpError TR_Interrupt(JdwpState*, Request* request, ExpandBuf* reply ATTRIBUTE_UNUSED)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId thread_id = request->ReadThreadId();
  return Dbg::Interrupt(thread_id);
}

/*
 * Return the debug suspend count for the specified thread.
 *
 * (The thread *might* still be running -- it might not have examined
 * its suspend count recently.)
 */
static JdwpError TR_DebugSuspendCount(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId thread_id = request->ReadThreadId();
  return Dbg::GetThreadDebugSuspendCount(thread_id, pReply);
}

/*
 * Return the name of a thread group.
 *
 * The Eclipse debugger recognizes ""main"" and ""system"" as special.
 */
static JdwpError TGR_Name(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId thread_group_id = request->ReadThreadGroupId();
  return Dbg::GetThreadGroupName(thread_group_id, pReply);
}

/*
 * Returns the thread group -- if any -- that contains the specified
 * thread group.
 */
static JdwpError TGR_Parent(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId thread_group_id = request->ReadThreadGroupId();
  return Dbg::GetThreadGroupParent(thread_group_id, pReply);
}

/*
 * Return the active threads and thread groups that are part of the
 * specified thread group.
 */
static JdwpError TGR_Children(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId thread_group_id = request->ReadThreadGroupId();
  return Dbg::GetThreadGroupChildren(thread_group_id, pReply);
}

/*
 * Return the #of components in the array.
 */
static JdwpError AR_Length(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId array_id = request->ReadArrayId();

  int32_t length;
  JdwpError status = Dbg::GetArrayLength(array_id, &length);
  if (status != ERR_NONE) {
    return status;
  }
  VLOG(jdwp) << ""    --> "" << length;

  expandBufAdd4BE(pReply, length);

  return ERR_NONE;
}

/*
 * Return the values from an array.
 */
static JdwpError AR_GetValues(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId array_id = request->ReadArrayId();
  uint32_t offset = request->ReadUnsigned32(""offset"");
  uint32_t length = request->ReadUnsigned32(""length"");
  return Dbg::OutputArray(array_id, offset, length, pReply);
}

/*
 * Set values in an array.
 */
static JdwpError AR_SetValues(JdwpState*, Request* request, ExpandBuf*)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId array_id = request->ReadArrayId();
  uint32_t offset = request->ReadUnsigned32(""offset"");
  uint32_t count = request->ReadUnsigned32(""count"");
  return Dbg::SetArrayElements(array_id, offset, count, request);
}

static JdwpError CLR_VisibleClasses(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  request->ReadObjectId();  // classLoaderObject
  // TODO: we should only return classes which have the given class loader as a defining or
  // initiating loader. The former would be easy; the latter is hard, because we don't have
  // any such notion.
  return VM_AllClassesImpl(pReply, false, false);
}

// Delete function class to use std::unique_ptr with JdwpEvent.
struct JdwpEventDeleter {
  void operator()(JdwpEvent* event) {
    EventFree(event);
  }
};

/*
 * Set an event trigger.
 *
 * Reply with a requestID.
 */
static JdwpError ER_Set(JdwpState* state, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  JdwpEventKind event_kind = request->ReadEnum1<JdwpEventKind>(""event kind"");
  JdwpSuspendPolicy suspend_policy = request->ReadEnum1<JdwpSuspendPolicy>(""suspend policy"");
  int32_t modifier_count = request->ReadSigned32(""modifier count"");

  CHECK_LT(modifier_count, 256);    /* reasonableness check */

  std::unique_ptr<JDWP::JdwpEvent, JdwpEventDeleter> pEvent(EventAlloc(modifier_count));
  pEvent->eventKind = event_kind;
  pEvent->suspend_policy = suspend_policy;
  pEvent->modCount = modifier_count;

  /*
   * Read modifiers.  Ordering may be significant (see explanation of Count
   * mods in JDWP doc).
   */
  for (int32_t i = 0; i < modifier_count; ++i) {
    JdwpEventMod& mod = pEvent->mods[i];
    mod.modKind = request->ReadModKind();
    switch (mod.modKind) {
    case MK_COUNT:
      {
        // Report once, when ""--count"" reaches 0.
        uint32_t count = request->ReadUnsigned32(""count"");
        if (count == 0) {
          return ERR_INVALID_COUNT;
        }
        mod.count.count = count;
      }
      break;
    case MK_CONDITIONAL:
      {
        // Conditional on expression.
        uint32_t exprId = request->ReadUnsigned32(""expr id"");
        mod.conditional.exprId = exprId;
      }
      break;
    case MK_THREAD_ONLY:
      {
        // Only report events in specified thread.
        ObjectId thread_id = request->ReadThreadId();
        mod.threadOnly.threadId = thread_id;
      }
      break;
    case MK_CLASS_ONLY:
      {
        // For ClassPrepare, MethodEntry.
        RefTypeId class_id = request->ReadRefTypeId();
        mod.classOnly.refTypeId = class_id;
      }
      break;
    case MK_CLASS_MATCH:
      {
        // Restrict events to matching classes.
        // pattern is ""java.foo.*"", we want ""java/foo/*"".
        std::string pattern(request->ReadUtf8String());
        std::replace(pattern.begin(), pattern.end(), '.', '/');
        mod.classMatch.classPattern = strdup(pattern.c_str());
      }
      break;
    case MK_CLASS_EXCLUDE:
      {
        // Restrict events to non-matching classes.
        // pattern is ""java.foo.*"", we want ""java/foo/*"".
        std::string pattern(request->ReadUtf8String());
        std::replace(pattern.begin(), pattern.end(), '.', '/');
        mod.classExclude.classPattern = strdup(pattern.c_str());
      }
      break;
    case MK_LOCATION_ONLY:
      {
        // Restrict certain events based on location.
        JdwpLocation location = request->ReadLocation();
        mod.locationOnly.loc = location;
      }
      break;
    case MK_EXCEPTION_ONLY:
      {
        // Modifies EK_EXCEPTION events,
        mod.exceptionOnly.refTypeId = request->ReadRefTypeId();  // null => all exceptions.
        mod.exceptionOnly.caught = request->ReadEnum1<uint8_t>(""caught"");
        mod.exceptionOnly.uncaught = request->ReadEnum1<uint8_t>(""uncaught"");
      }
      break;
    case MK_FIELD_ONLY:
      {
        // For field access/modification events.
        RefTypeId declaring = request->ReadRefTypeId();
        FieldId fieldId = request->ReadFieldId();
        mod.fieldOnly.refTypeId = declaring;
        mod.fieldOnly.fieldId = fieldId;
      }
      break;
    case MK_STEP:
      {
        // For use with EK_SINGLE_STEP.
        ObjectId thread_id = request->ReadThreadId();
        uint32_t size = request->ReadUnsigned32(""step size"");
        uint32_t depth = request->ReadUnsigned32(""step depth"");
        VLOG(jdwp) << StringPrintf(""    Step: thread=%#"" PRIx64, thread_id)
                     << "" size="" << JdwpStepSize(size) << "" depth="" << JdwpStepDepth(depth);

        mod.step.threadId = thread_id;
        mod.step.size = size;
        mod.step.depth = depth;
      }
      break;
    case MK_INSTANCE_ONLY:
      {
        // Report events related to a specific object.
        ObjectId instance = request->ReadObjectId();
        mod.instanceOnly.objectId = instance;
      }
      break;
    default:
      LOG(WARNING) << ""Unsupported modifier "" << mod.modKind << "" for event "" << pEvent->eventKind;
      return JDWP::ERR_NOT_IMPLEMENTED;
    }
  }

  /*
   * We reply with an integer ""requestID"".
   */
  uint32_t requestId = state->NextEventSerial();
  expandBufAdd4BE(pReply, requestId);

  pEvent->requestId = requestId;

  VLOG(jdwp) << StringPrintf(""    --> event requestId=%#x"", requestId);

  /* add it to the list */
  JdwpError err = state->RegisterEvent(pEvent.get());
  if (err != ERR_NONE) {
    /* registration failed, probably because event is bogus */
    LOG(WARNING) << ""WARNING: event request rejected"";
    return err;
  }
  pEvent.release();
  return ERR_NONE;
}

static JdwpError ER_Clear(JdwpState* state, Request* request, ExpandBuf*)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  request->ReadEnum1<JdwpEventKind>(""event kind"");
  uint32_t requestId = request->ReadUnsigned32(""request id"");

  // Failure to find an event with a matching ID is a no-op
  // and does not return an error.
  state->UnregisterEventById(requestId);
  return ERR_NONE;
}

/*
 * Return the values of arguments and local variables.
 */
static JdwpError SF_GetValues(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  return Dbg::GetLocalValues(request, pReply);
}

/*
 * Set the values of arguments and local variables.
 */
static JdwpError SF_SetValues(JdwpState*, Request* request, ExpandBuf*)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  return Dbg::SetLocalValues(request);
}

static JdwpError SF_ThisObject(JdwpState*, Request* request, ExpandBuf* reply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  ObjectId thread_id = request->ReadThreadId();
  FrameId frame_id = request->ReadFrameId();

  ObjectId object_id;
  JdwpError rc = Dbg::GetThisObject(thread_id, frame_id, &object_id);
  if (rc != ERR_NONE) {
    return rc;
  }

  return WriteTaggedObject(reply, object_id);
}

/*
 * Return the reference type reflected by this class object.
 *
 * This appears to be required because ReferenceTypeId values are NEVER
 * reused, whereas ClassIds can be recycled like any other object.  (Either
 * that, or I have no idea what this is for.)
 */
static JdwpError COR_ReflectedType(JdwpState*, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  RefTypeId class_object_id = request->ReadRefTypeId();
  return Dbg::GetReflectedType(class_object_id, pReply);
}

/*
 * Handle a DDM packet with a single chunk in it.
 */
static JdwpError DDM_Chunk(JdwpState* state, Request* request, ExpandBuf* pReply)
    SHARED_REQUIRES(Locks::mutator_lock_) {
  state->NotifyDdmsActive();
  uint8_t* replyBuf = nullptr;
  int replyLen = -1;
  if (Dbg::DdmHandlePacket(request, &replyBuf, &replyLen)) {
    // If they want to send something back, we copy it into the buffer.
    // TODO: consider altering the JDWP stuff to hold the packet header
    // in a separate buffer.  That would allow us to writev() DDM traffic
    // instead of copying it into the expanding buffer.  The reduction in
    // heap requirements is probably more valuable than the efficiency.
    CHECK_GT(replyLen, 0);
    memcpy(expandBufAddSpace(pReply, replyLen), replyBuf, replyLen);
    delete[] replyBuf;
  }
  return ERR_NONE;
}

/*
 * Handler map decl.
 */
typedef JdwpError (*JdwpRequestHandler)(JdwpState* state, Request* request, ExpandBuf* reply);

struct JdwpHandlerMap {
  uint8_t cmdSet;
  uint8_t cmd;
  JdwpRequestHandler func;
  const char* name;
};

/*
 * Map commands to functions.
 *
 * Command sets 0-63 are incoming requests, 64-127 are outbound requests,
 * and 128-256 are vendor-defined.
 */
static const JdwpHandlerMap gHandlers[] = {
  /* VirtualMachine command set (1) */
  { 1,    1,  VM_Version,               ""VirtualMachine.Version"" },
  { 1,    2,  VM_ClassesBySignature,    ""VirtualMachine.ClassesBySignature"" },
  { 1,    3,  VM_AllClasses,            ""VirtualMachine.AllClasses"" },
  { 1,    4,  VM_AllThreads,            ""VirtualMachine.AllThreads"" },
  { 1,    5,  VM_TopLevelThreadGroups,  ""VirtualMachine.TopLevelThreadGroups"" },
  { 1,    6,  VM_Dispose,               ""VirtualMachine.Dispose"" },
  { 1,    7,  VM_IDSizes,               ""VirtualMachine.IDSizes"" },
  { 1,    8,  VM_Suspend,               ""VirtualMachine.Suspend"" },
  { 1,    9,  VM_Resume,                ""VirtualMachine.Resume"" },
  { 1,    10, VM_Exit,                  ""VirtualMachine.Exit"" },
  { 1,    11, VM_CreateString,          ""VirtualMachine.CreateString"" },
  { 1,    12, VM_Capabilities,          ""VirtualMachine.Capabilities"" },
  { 1,    13, VM_ClassPaths,            ""VirtualMachine.ClassPaths"" },
  { 1,    14, VM_DisposeObjects,        ""VirtualMachine.DisposeObjects"" },
  { 1,    15, nullptr,                  ""VirtualMachine.HoldEvents"" },
  { 1,    16, nullptr,                  ""VirtualMachine.ReleaseEvents"" },
  { 1,    17, VM_CapabilitiesNew,       ""VirtualMachine.CapabilitiesNew"" },
  { 1,    18, nullptr,                  ""VirtualMachine.RedefineClasses"" },
  { 1,    19, nullptr,                  ""VirtualMachine.SetDefaultStratum"" },
  { 1,    20, VM_AllClassesWithGeneric, ""VirtualMachine.AllClassesWithGeneric"" },
  { 1,    21, VM_InstanceCounts,        ""VirtualMachine.InstanceCounts"" },

  /* ReferenceType command set (2) */
  { 2,    1,  RT_Signature,            ""ReferenceType.Signature"" },
  { 2,    2,  RT_ClassLoader,          ""ReferenceType.ClassLoader"" },
  { 2,    3,  RT_Modifiers,            ""ReferenceType.Modifiers"" },
  { 2,    4,  RT_Fields,               ""ReferenceType.Fields"" },
  { 2,    5,  RT_Methods,              ""ReferenceType.Methods"" },
  { 2,    6,  RT_GetValues,            ""ReferenceType.GetValues"" },
  { 2,    7,  RT_SourceFile,           ""ReferenceType.SourceFile"" },
  { 2,    8,  nullptr,                 ""ReferenceType.NestedTypes"" },
  { 2,    9,  RT_Status,               ""ReferenceType.Status"" },
  { 2,    10, RT_Interfaces,           ""ReferenceType.Interfaces"" },
  { 2,    11, RT_ClassObject,          ""ReferenceType.ClassObject"" },
  { 2,    12, RT_SourceDebugExtension, ""ReferenceType.SourceDebugExtension"" },
  { 2,    13, RT_SignatureWithGeneric, ""ReferenceType.SignatureWithGeneric"" },
  { 2,    14, RT_FieldsWithGeneric,    ""ReferenceType.FieldsWithGeneric"" },
  { 2,    15, RT_MethodsWithGeneric,   ""ReferenceType.MethodsWithGeneric"" },
  { 2,    16, RT_Instances,            ""ReferenceType.Instances"" },
  { 2,    17, nullptr,                 ""ReferenceType.ClassFileVersion"" },
  { 2,    18, nullptr,                 ""ReferenceType.ConstantPool"" },

  /* ClassType command set (3) */
  { 3,    1,  CT_Superclass,    ""ClassType.Superclass"" },
  { 3,    2,  CT_SetValues,     ""ClassType.SetValues"" },
  { 3,    3,  CT_InvokeMethod,  ""ClassType.InvokeMethod"" },
  { 3,    4,  CT_NewInstance,   ""ClassType.NewInstance"" },

  /* ArrayType command set (4) */
  { 4,    1,  AT_newInstance,   ""ArrayType.NewInstance"" },

  /* InterfaceType command set (5) */
  { 5,    1, IT_InvokeMethod,  ""InterfaceType.InvokeMethod"" },

  /* Method command set (6) */
  { 6,    1,  M_LineTable,                ""Method.LineTable"" },
  { 6,    2,  M_VariableTable,            ""Method.VariableTable"" },
  { 6,    3,  M_Bytecodes,                ""Method.Bytecodes"" },
  { 6,    4,  M_IsObsolete,               ""Method.IsObsolete"" },
  { 6,    5,  M_VariableTableWithGeneric, ""Method.VariableTableWithGeneric"" },

  /* Field command set (8) */

  /* ObjectReference command set (9) */
  { 9,    1,  OR_ReferenceType,     ""ObjectReference.ReferenceType"" },
  { 9,    2,  OR_GetValues,         ""ObjectReference.GetValues"" },
  { 9,    3,  OR_SetValues,         ""ObjectReference.SetValues"" },
  { 9,    4,  nullptr,              ""ObjectReference.UNUSED"" },
  { 9,    5,  OR_MonitorInfo,       ""ObjectReference.MonitorInfo"" },
  { 9,    6,  OR_InvokeMethod,      ""ObjectReference.InvokeMethod"" },
  { 9,    7,  OR_DisableCollection, ""ObjectReference.DisableCollection"" },
  { 9,    8,  OR_EnableCollection,  ""ObjectReference.EnableCollection"" },
  { 9,    9,  OR_IsCollected,       ""ObjectReference.IsCollected"" },
  { 9,    10, OR_ReferringObjects,  ""ObjectReference.ReferringObjects"" },

  /* StringReference command set (10) */
  { 10,   1,  SR_Value,         ""StringReference.Value"" },

  /* ThreadReference command set (11) */
  { 11,   1,  TR_Name,                        ""ThreadReference.Name"" },
  { 11,   2,  TR_Suspend,                     ""ThreadReference.Suspend"" },
  { 11,   3,  TR_Resume,                      ""ThreadReference.Resume"" },
  { 11,   4,  TR_Status,                      ""ThreadReference.Status"" },
  { 11,   5,  TR_ThreadGroup,                 ""ThreadReference.ThreadGroup"" },
  { 11,   6,  TR_Frames,                      ""ThreadReference.Frames"" },
  { 11,   7,  TR_FrameCount,                  ""ThreadReference.FrameCount"" },
  { 11,   8,  TR_OwnedMonitors,               ""ThreadReference.OwnedMonitors"" },
  { 11,   9,  TR_CurrentContendedMonitor,     ""ThreadReference.CurrentContendedMonitor"" },
  { 11,   10, nullptr,                        ""ThreadReference.Stop"" },
  { 11,   11, TR_Interrupt,                   ""ThreadReference.Interrupt"" },
  { 11,   12, TR_DebugSuspendCount,           ""ThreadReference.SuspendCount"" },
  { 11,   13, TR_OwnedMonitorsStackDepthInfo, ""ThreadReference.OwnedMonitorsStackDepthInfo"" },
  { 11,   14, nullptr,                        ""ThreadReference.ForceEarlyReturn"" },

  /* ThreadGroupReference command set (12) */
  { 12,   1,  TGR_Name,         ""ThreadGroupReference.Name"" },
  { 12,   2,  TGR_Parent,       ""ThreadGroupReference.Parent"" },
  { 12,   3,  TGR_Children,     ""ThreadGroupReference.Children"" },

  /* ArrayReference command set (13) */
  { 13,   1,  AR_Length,        ""ArrayReference.Length"" },
  { 13,   2,  AR_GetValues,     ""ArrayReference.GetValues"" },
  { 13,   3,  AR_SetValues,     ""ArrayReference.SetValues"" },

  /* ClassLoaderReference command set (14) */
  { 14,   1,  CLR_VisibleClasses, ""ClassLoaderReference.VisibleClasses"" },

  /* EventRequest command set (15) */
  { 15,   1,  ER_Set,           ""EventRequest.Set"" },
  { 15,   2,  ER_Clear,         ""EventRequest.Clear"" },
  { 15,   3,  nullptr,          ""EventRequest.ClearAllBreakpoints"" },

  /* StackFrame command set (16) */
  { 16,   1,  SF_GetValues,     ""StackFrame.GetValues"" },
  { 16,   2,  SF_SetValues,     ""StackFrame.SetValues"" },
  { 16,   3,  SF_ThisObject,    ""StackFrame.ThisObject"" },
  { 16,   4,  nullptr,          ""StackFrame.PopFrames"" },

  /* ClassObjectReference command set (17) */
  { 17,   1,  COR_ReflectedType, ""ClassObjectReference.ReflectedType"" },

  /* Event command set (64) */
  { 64, 100,  nullptr, ""Event.Composite"" },  // sent from VM to debugger, never received by VM

  { 199,  1,  DDM_Chunk,        ""DDM.Chunk"" },
};

static const char* GetCommandName(Request* request) {
  for (size_t i = 0; i < arraysize(gHandlers); ++i) {
    if (gHandlers[i].cmdSet == request->GetCommandSet() &&
        gHandlers[i].cmd == request->GetCommand()) {
      return gHandlers[i].name;
    }
  }
  return ""?UNKNOWN?"";
}

static std::string DescribeCommand(Request* request) {
  std::string result;
  result += ""REQUEST: "";
  result += GetCommandName(request);
  result += StringPrintf("" (length=%zu id=0x%06x)"", request->GetLength(), request->GetId());
  return result;
}

// Returns true if the given command_set and command identify an ""invoke"" command.
static bool IsInvokeCommand(uint8_t command_set, uint8_t command) {
  if (command_set == kJDWPClassTypeCmdSet) {
    return command == kJDWPClassTypeInvokeMethodCmd || command == kJDWPClassTypeNewInstanceCmd;
  } else if (command_set == kJDWPObjectReferenceCmdSet) {
    return command == kJDWPObjectReferenceInvokeCmd;
  } else if (command_set == kJDWPInterfaceTypeCmdSet) {
    return command == kJDWPInterfaceTypeInvokeMethodCmd;
  } else {
    return false;
  }
}

/*
 * Process a request from the debugger. The skip_reply flag is set to true to indicate to the
 * caller the reply must not be sent to the debugger. This is used for invoke commands where the
 * reply is sent by the event thread after completing the invoke.
 *
 * On entry, the JDWP thread is in VMWAIT.
 */
size_t JdwpState::ProcessRequest(Request* request, ExpandBuf* pReply, bool* skip_reply) {
  JdwpError result = ERR_NONE;
  *skip_reply = false;

  if (request->GetCommandSet() != kJDWPDdmCmdSet) {
    /*
     * Activity from a debugger, not merely ddms.  Mark us as having an
     * active debugger session, and zero out the last-activity timestamp
     * so waitForDebugger() doesn't return if we stall for a bit here.
     */
    Dbg::GoActive();
    last_activity_time_ms_.StoreSequentiallyConsistent(0);
  }

  /*
   * If a debugger event has fired in another thread, wait until the
   * initiating thread has suspended itself before processing commands
   * from the debugger.  Otherwise we (the JDWP thread) could be told to
   * resume the thread before it has suspended.
   *
   * Note that we MUST clear the event token before waking the event
   * thread up, or risk waiting for the thread to suspend after we've
   * told it to resume.
   */
  AcquireJdwpTokenForCommand();

  /*
   * Tell the VM that we're running and shouldn't be interrupted by GC.
   * Do this after anything that can stall indefinitely.
   */
  Thread* self = Thread::Current();
  ScopedObjectAccess soa(self);

  expandBufAddSpace(pReply, kJDWPHeaderLen);

  size_t i;
  for (i = 0; i < arraysize(gHandlers); ++i) {
    if (gHandlers[i].cmdSet == request->GetCommandSet() &&
        gHandlers[i].cmd == request->GetCommand() &&
        gHandlers[i].func != nullptr) {
      VLOG(jdwp) << DescribeCommand(request);
      result = (*gHandlers[i].func)(this, request, pReply);
      if (result == ERR_NONE) {
        request->CheckConsumed();
      }
      self->AssertNoPendingException();
      break;
    }
  }
  if (i == arraysize(gHandlers)) {
    LOG(ERROR) << ""Command not implemented: "" << DescribeCommand(request);
    LOG(ERROR) << HexDump(request->data(), request->size(), false, """");
    result = ERR_NOT_IMPLEMENTED;
  }

  size_t replyLength = 0U;
  if (result == ERR_NONE && IsInvokeCommand(request->GetCommandSet(), request->GetCommand())) {
    // We successfully request an invoke in the event thread. It will send the reply once the
    // invoke completes so we must not send it now.
    *skip_reply = true;
  } else {
    /*
     * Set up the reply header.
     *
     * If we encountered an error, only send the header back.
     */
    uint8_t* replyBuf = expandBufGetBuffer(pReply);
    replyLength = (result == ERR_NONE) ? expandBufGetLength(pReply) : kJDWPHeaderLen;
    Set4BE(replyBuf + kJDWPHeaderSizeOffset, replyLength);
    Set4BE(replyBuf + kJDWPHeaderIdOffset, request->GetId());
    Set1(replyBuf + kJDWPHeaderFlagsOffset, kJDWPFlagReply);
    Set2BE(replyBuf + kJDWPHeaderErrorCodeOffset, result);

    CHECK_GT(expandBufGetLength(pReply), 0U) << GetCommandName(request) << "" "" << request->GetId();

    size_t respLen = expandBufGetLength(pReply) - kJDWPHeaderLen;
    VLOG(jdwp) << ""REPLY: "" << GetCommandName(request) << "" "" << result << "" (length="" << respLen << "")"";
    if (false) {
      VLOG(jdwp) << HexDump(expandBufGetBuffer(pReply) + kJDWPHeaderLen, respLen, false, """");
    }
  }

  VLOG(jdwp) << ""----------"";

  /*
   * Update last-activity timestamp.  We really only need this during
   * the initial setup.  Only update if this is a non-DDMS packet.
   */
  if (request->GetCommandSet() != kJDWPDdmCmdSet) {
    last_activity_time_ms_.StoreSequentiallyConsistent(MilliTime());
  }

  return replyLength;
}

}  // namespace JDWP

}  // namespace art
",16337,True,3406.2784392925896,median
"<<<
:sectnums:
=== Control and Status Registers (CSRs)

The following table shows a summary of all available CSRs. The address field defines the CSR address for
the CSR access instructions. The *[ASM]* name can be used for (inline) assembly code and is directly
understood by the assembler/compiler. The *[C]* names are defined by the NEORV32 core library and can be
used as immediate in plain C code. The *R/W* column shows whether the CSR can be read and/or written.
The NEORV32-specific CSRs are mapped to the official ""custom CSRs"" CSR address space.

.Mandatory `Zicsr` Extension
[IMPORTANT]
The CSRs, the CSR-related instructions and the complete exception/interrupt processing
system are only available when the <<_cpu_extension_riscv_zicsr>> generic is _true_.

.CSR Access Exception
[IMPORTANT]
When trying to write to a read-only CSR (like the `time` CSR) or when trying to access a nonexistent
CSR or when trying to access a machine-mode CSR from less-privileged user-mode an
illegal instruction exception is raised.

.CSR Reset Value
[IMPORTANT]
Please note that most of the CSRs do *NOT* provide a dedicated reset. Hence,
these CSRs are not initialized by a hardware reset and provide an *UNDEFINED* value until they are
explicitly initialized by the software (normally, this is done by the NEORV32-specific
`crt0.S` start-up code). For more information see section <<_cpu_hardware_reset>>.


**CSR Listing**

The description of each single CSR provides the following summary:

.CSR description
[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| _Address_ | _Description_ | _ASM alias_
3+| Reset value: _CSR content after hardware reset_ (also see <<_cpu_hardware_reset>>)
3+| _Detailed description_
|=======================

.Not Implemented CSRs / CSR Bits
[IMPORTANT]
All CSR bits that are unused / not implemented / not shown are _hardwired to zero_. All CSRs that are not
implemented at all (and are not ""disabled"" using certain configuration generics) will trigger an exception on
access. The CSR that are implemented within the NEORV32 might cause an exception if they are disabled.
See the according CSR description for more information.

.Debug Mode CSRs
[IMPORTANT]
The _debug mode_ CSRs are not listed here since they are accessible only in debug mode and not during _normal_ CPU operation.
See section <<_cpu_debug_mode_csrs>> for more information.


<<<
// ####################################################################################################################
**CSR Listing Notes**

CSRs with the following notes ...

* `X`: _custom_ - have or are a custom CPU-specific extension (which is allowed by the RISC-V specs)
* `R`: _read-only_ - are read-only (in contrast to the originally specified r/w capability)
* `C`: _constrained_ - have a constrained compatibility, not all specified bits are implemented

.NEORV32 Control and Status Registers (CSRs)
[cols=""<6,<11,<16,^3,<25,^3""]
[options=""header""]
|=======================
| Address | Name [ASM] | Name [C] | R/W | Function | Note
6+^| **<<_floating_point_csrs>>**
| 0x001   | <<_fflags>>     | _CSR_FFLAGS_     | r/w | Floating-point accrued exceptions | 
| 0x002   | <<_frm>>        | _CSR_FRM_        | r/w | Floating-point dynamic rounding mode | 
| 0x003   | <<_fcsr>>       | _CSR_FCSR_       | r/w | Floating-point control and status (`frm` + `fflags`) | 
6+^| **<<_machine_configuration_csrs>>**
| 0x30a   | <<_menvcfg>>    | _CSR_MENVCFG_    | r/- | Machine environment configuration register - low word | `R`
| 0x31a   | <<_menvcfgh>>   | _CSR_MENVCFGH_   | r/- | Machine environment configuration register - low word | `R`
6+^| **<<_machine_trap_setup_csrs>>**
| 0x300   | <<_mstatus>>    | _CSR_MSTATUS_    | r/w | Machine status register - low word | `C`
| 0x301   | <<_misa>>       | _CSR_MISA_       | r/- | Machine CPU ISA and extensions | `R`
| 0x304   | <<_mie>>        | _CSR_MIE_        | r/w | Machine interrupt enable register | `X`
| 0x305   | <<_mtvec>>      | _CSR_MTVEC_      | r/w | Machine trap-handler base address (for ALL traps) | 
| 0x306   | <<_mcounteren>> | _CSR_MCOUNTEREN_ | r/w | Machine counter-enable register | `C`
| 0x310   | <<_mstatush>>   | _CSR_MSTATUSH_   | r/- | Machine status register - high word | `R`
6+^| **<<_machine_trap_handling_csrs>>**
| 0x340   | <<_mscratch>>   | _CSR_MSCRATCH_   | r/w | Machine scratch register | 
| 0x341   | <<_mepc>>       | _CSR_MEPC_       | r/w | Machine exception program counter | 
| 0x342   | <<_mcause>>     | _CSR_MCAUSE_     | r/w | Machine trap cause | `CX`
| 0x343   | <<_mtval>>      | _CSR_MTVAL_      | r/- | Machine bad address or instruction | `R`
| 0x344   | <<_mip>>        | _CSR_MIP_        | r/w | Machine interrupt pending register | `X`
6+^| **<<_machine_physical_memory_protection_csrs>>**
| 0x3a0 .. 0x3af | <<_pmpcfg, `pmpcfg0`>> .. <<_pmpcfg, `pmpcfg3`>>     | _CSR_PMPCFG0_ .. _CSR_PMPCFG3_   | r/w | Physical memory protection config. for region 0..15 | `C`
| 0x3b0 .. 0x3ef | <<_pmpaddr, `pmpaddr0`>> .. <<_pmpaddr, `pmpaddr15`>> | _CSR_PMPADDR0_ .. _CSR_PMPADDR15_ | r/w | Physical memory protection addr. register region 0..15 | 
6+^| **<<_machine_counter_and_timer_csrs>>**
| 0xb00   | <<_mcycleh, `mcycle`>>      | _CSR_MCYCLE_     | r/w | Machine cycle counter low word | 
| 0xb02   | <<_minstreth, `minstret`>> | _CSR_MINSTRET_    | r/w | Machine instruction-retired counter low word | 
| 0xb80   | <<_mcycleh>>                | _CSR_MCYCLE_     | r/w | Machine cycle counter high word | 
| 0xb82   | <<_minstreth>>              | _CSR_MINSTRET_   | r/w | Machine instruction-retired counter high word |
| 0xc00   | <<_cycleh, `cycle`>>        | _CSR_CYCLE_      | r/- | Cycle counter low word | 
| 0xc01   | <<_timeh, `time`>>          | _CSR_TIME_       | r/- | System time (from MTIME) low word | 
| 0xc02   | <<_instreth, `instret`>>    | _CSR_INSTRET_    | r/- | Instruction-retired counter low word |  
| 0xc80   | <<_cycleh>>                 | _CSR_CYCLEH_     | r/- | Cycle counter high word | 
| 0xc81   | <<_timeh>>                  | _CSR_TIMEH_      | r/- | System time (from MTIME) high word | 
| 0xc82   | <<_instreth>>               | _CSR_INSTRETH_   | r/- | Instruction-retired counter high word | 
6+^| **<<_hardware_performance_monitors_hpm_csrs>>**
| 0x323 .. 0x33f | <<_mhpmevent, `mhpmevent3`>> .. <<_mhpmevent, `mhpmevent31`>>             | _CSR_MHPMEVENT3_ .. _CSR_MHPMEVENT31_       | r/w | Machine performance-monitoring event selector 3..31 | `X`
| 0xb03 .. 0xb1f | <<_mhpmcounterh, `mhpmcounter3`>> .. <<_mhpmcounterh, `mhpmcounter31`>>   | _CSR_MHPMCOUNTER3_ .. _CSR_MHPMCOUNTER31_   | r/w | Machine performance-monitoring counter 3..31 low word | 
| 0xb83 .. 0xb9f | <<_mhpmcounterh, `mhpmcounter3h`>> .. <<_mhpmcounterh, `mhpmcounter31h`>> | _CSR_MHPMCOUNTER3H_ .. _CSR_MHPMCOUNTER31H_ | r/w | Machine performance-monitoring counter 3..31 high word | 
6+^| **<<_machine_counter_setup_csrs>>**
| 0x320   | <<_mcountinhibit>> | _CSR_MCOUNTINHIBIT_ | r/w | Machine counter-enable register |
6+^| **<<_machine_information_csrs>>**
| 0xf11   | <<_mvendorid>>  | _CSR_MVENDORID_  | r/- | Vendor ID |
| 0xf12   | <<_marchid>>    | _CSR_MARCHID_    | r/- | Architecture ID |
| 0xf13   | <<_mimpid>>     | _CSR_MIMPID_     | r/- | Machine implementation ID / version |
| 0xf14   | <<_mhartid>>    | _CSR_MHARTID_    | r/- | Machine thread ID |
| 0xf15   | <<_mconfigptr>> | _CSR_MCONFIGPTR_ | r/- | Machine configuration pointer register |
6+^| **<<_neorv32_specific_csrs>>**
| 0xfc0   | <<_mxisa>>       | _CSR_MXISA_     | r/- | NEORV32-specific ""extended"" machine CPU ISA and extensions | `X`
|=======================



<<<
// ####################################################################################################################
:sectnums:
==== Floating-Point CSRs

These CSRs are available if the `Zfinx` extensions is enabled (`CPU_EXTENSION_RISCV_Zfinx` is _true_).
Otherwise any access to the floating-point CSRs will raise an illegal instruction exception.


:sectnums!:
===== **`fflags`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x001 | **Floating-point accrued exceptions** | `fflags`
3+| Reset value: _UNDEFINED_
3+| The `fflags` CSR is compatible to the RISC-V specifications. It shows the accrued (""accumulated"")
exception flags in the lowest 5 bits. This CSR is only available if a floating-point CPU extension is enabled.
See the RISC-V ISA spec for more information.
|=======================


:sectnums!:
===== **`frm`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x002 | **Floating-point dynamic rounding mode** | `frm`
3+| Reset value: _UNDEFINED_
3+| The `frm` CSR is compatible to the RISC-V specifications and is used to configure the rounding modes using
the lowest 3 bits. This CSR is only available if a floating-point CPU extension is enabled. See the RISC-V
ISA spec for more information.
|=======================


:sectnums!:
===== **`fcsr`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x003 | **Floating-point control and status register** | `fcsr`
3+| Reset value: _UNDEFINED_
3+| The `fcsr` CSR is compatible to the RISC-V specifications. It provides combined read/write access to the
`fflags` and `frm` CSRs. This CSR is only available if a floating-point CPU extension is enabled. See the
RISC-V ISA spec for more information.
|=======================


<<<
// ####################################################################################################################
:sectnums:
==== Machine Configuration CSRs

:sectnums!:
===== **`menvcfg`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x30a | **Machine environment configuration register** | `menvcfg`
3+| Reset value: _0x00000000_
3+| The features of this CSR are not implemented yet. The register is read-only. NOTE: This register
only exists if the `U` ISA extensions is enabled.
|=======================


:sectnums!:
===== **`menvcfgh`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x31a | **Machine environment configuration register - high word** | `menvcfgh`
3+| Reset value: _0x00000000_
3+| The features of this CSR are not implemented yet. The register is read-only. NOTE: This register
only exists if the `U` ISA extensions is enabled.
|=======================


<<<
// ####################################################################################################################
:sectnums:
==== Machine Trap Setup CSRs

:sectnums!:
===== **`mstatus`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x300 | **Machine status register** | `mstatus`
3+| Reset value: _0x00000000_
3+| The `mstatus` CSR is compatible to the RISC-V specifications. It shows the CPU's current execution state.
The following bits are implemented (all remaining bits are always zero and are read-only).
|=======================

.Machine status register
[cols=""^1,<3,^1,<5""]
[options=""header"",grid=""rows""]
|=======================
| Bit   | Name [C] | R/W | Function
| 21    | _CSR_MSTATUS_TW_   | r/w | **TW**: Disallows execution of `wfi` instruction in user mode when set; hardwired to zero if user-mode not implemented
| 12:11 | _CSR_MSTATUS_MPP_H_ : _CSR_MSTATUS_MPP_L_ | r/w | **MPP*: Previous machine privilege level, 11 = machine (M) level, 00 = user (U) level
| 7     | _CSR_MSTATUS_MPIE_ | r/w | **MPIE**: Previous machine global interrupt enable flag state
| 3     | _CSR_MSTATUS_MIE_  | r/w | **MIE**: Machine global interrupt enable flag
|=======================

When entering an exception/interrupt, the `MIE` flag is copied to `MPIE` and cleared afterwards. When leaving
the exception/interrupt (via the `mret` instruction), `MPIE` is copied back to `MIE`.


:sectnums!:
===== **`misa`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x301 | **ISA and extensions** | `misa`
3+| Reset value: _defined_
3+| The `misa` CSR gives information about the actual CPU features. The lowest 26 bits show the implemented
CPU extensions. The following bits are implemented (all remaining bits are always zero and are read-only).
|=======================

[IMPORTANT]
The `misa` CSR is not fully RISC-V-compatible as it is read-only. Hence, implemented CPU
extensions cannot be switch on/off during runtime. For compatibility reasons any write access to this
CSR is simply ignored and will _NOT_ cause an illegal instruction exception.

.Machine ISA and extension register
[cols=""^1,<3,^1,<5""]
[options=""header"",grid=""rows""]
|=======================
| Bit   | Name [C] | R/W | Function
| 31:30 | _CSR_MISA_MXL_HI_EXT_ : _CSR_MISA_MXL_LO_EXT_ | r/- | **MXL**: 32-bit architecture indicator (always _01_)
| 23    | _CSR_MISA_X_EXT_ | r/- | **X**: extension bit is always set to indicate custom non-standard extensions
| 20    | _CSR_MISA_U_EXT_ | r/- | **U**: CPU extension (user mode) available, set when _CPU_EXTENSION_RISCV_U_ enabled
| 12    | _CSR_MISA_M_EXT_ | r/- | **M**: CPU extension (mul/div) available, set when _CPU_EXTENSION_RISCV_M_ enabled
| 8     | _CSR_MISA_I_EXT_ | r/- | **I**: CPU base ISA, cleared when _CPU_EXTENSION_RISCV_E_ enabled
| 4     | _CSR_MISA_E_EXT_ | r/- | **E**: CPU extension (embedded) available, set when _CPU_EXTENSION_RISCV_E_ enabled
| 2     | _CSR_MISA_C_EXT_ | r/- | **C**: CPU extension (compressed instruction) available, set when _CPU_EXTENSION_RISCV_C_ enabled
|=======================

[TIP]
Machine-mode software can discover available `Z*` _sub-extensions_ (like `Zicsr` or `Zfinx`) by checking the NEORV32-specific
<<_mxisa>> CSR.


:sectnums!:
===== **`mie`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x304 | **Machine interrupt-enable register** | `mie`
3+| Reset value: _UNDEFINED_
3+| The `mie` CSR is compatible to the RISC-V specifications and features custom extensions for the fast
interrupt channels. It is used to enabled specific interrupts sources. Please note that interrupts also have to be
globally enabled via the `CSR_MSTATUS_MIE` flag of the `mstatus` CSR. The following bits are implemented
(all remaining bits are always zero and are read-only):
|=======================

.Machine ISA and extension register
[cols=""^1,<3,^1,<5""]
[options=""header"",grid=""rows""]
|=======================
| Bit   | Name [C] | R/W | Function
| 31:16 | _CSR_MIE_FIRQ15E_ : _CSR_MIE_FIRQ0E_ | r/w | Fast interrupt channel 15..0 enable
| 11    | _CSR_MIE_MEIE_ | r/w | **MEIE**: Machine _external_ interrupt enable
| 7     | _CSR_MIE_MTIE_ | r/w | **MTIE**: Machine _timer_ interrupt enable (from _MTIME_)
| 3     | _CSR_MIE_MSIE_ | r/w | **MSIE**: Machine _software_ interrupt enable
|=======================


:sectnums!:
===== **`mtvec`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x305 | **Machine trap-handler base address** | `mtvec`
3+| Reset value: _UNDEFINED_
3+| The `mtvec` CSR is compatible to the RISC-V specifications. It stores the base address for ALL machine
traps. Thus, it defines the main entry point for exception/interrupt handling regardless of the actual trap
source. The lowest two bits of this register are always zero and cannot be modified (= address mode only).
Hence, the trap handler's base address has to be aligned to a 4-byte boundary.
|=======================

.Machine trap-handler base address
[cols=""^1,^1,<8""]
[options=""header"",grid=""rows""]
|=======================
| Bit  | R/W | Function
| 31:2 | r/w | **BASE**: 4-byte aligned base address of trap base handler
| 1:0  | r/- | **MODE**: Always zero; BASE defined entry for _all_ traps
|=======================


:sectnums!:
===== **`mcounteren`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x306 | **Machine counter enable** | `mcounteren`
3+| Reset value: _UNDEFINED_
3+| The `mcounteren` CSR is compatible to the RISC-V specifications. The bits of this CSR define which
counter/timer CSR can be accessed (read) from code running in a less-privileged modes. For example,
if user-level code tries to read from a counter/timer CSR without enabled access, an illegal instruction
exception is raised. NOTE: If the `U` ISA extension is not enabled this CSR does not exist.
|=======================

.Machine counter enable register
[cols=""^1,<3,^1,<5""]
[options=""header"",grid=""rows""]
|=======================
| Bit   | Name [C] | R/W | Function
| 31:3  | `0`                 | r/- | Always zero: user-level code is **not** allowed to read HPM counters
| 2     | _CSR_MCOUNTEREN_IR_ | r/w | **IR**: User-level code is allowed to read `cycle[h]` CSRs when set
| 1     | _CSR_MCOUNTEREN_TM_ | r/w | **TM**: User-level code is allowed to read `time[h]` CSRs when set
| 0     | _CSR_MCOUNTEREN_CY_ | r/w | **CY**: User-level code is allowed to read `instret[h]` CSRs when set
|=======================

.HPM Access
[NOTE]
Bits 3 to 31 are used to control user-level access to the <<_hardware_performance_monitors_hpm_csrs>>. In the NEORV32
CPU these bits are hardwired to zero. Hence, user-level software cannot access the HPMs. Accordingly, the
`pmcounter*[h]` CSRs are **not** implemented and any access will raise an illegal instruction exception.


:sectnums!:
===== **`mstatush`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x310 | **Machine status register - high word** | `mstatush`
3+| Reset value: _0x00000000_
3+| The `mstatush` CSR is compatible to the RISC-V specifications. In combination with <<_mstatus>> it shows additional
execution state information. The NEORV32 `mstatush` CSR is read-only and all bits are hardwired to zero.
|=======================



<<<
// ####################################################################################################################
:sectnums:
==== Machine Trap Handling CSRs

:sectnums!:
===== **`mscratch`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x340 | **Scratch register for machine trap handlers** | `mscratch`
3+| Reset value: _UNDEFINED_
3+| The `mscratch` CSR is compatible to the RISC-V specifications. It is a general purpose scratch register that
can be used by the exception/interrupt handler. The content pf this register after reset is undefined.
|=======================

:sectnums!:
===== **`mepc`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x341 | **Machine exception program counter** | `mepc`
3+| Reset value: _UNDEFINED_
3+| The `mepc` CSR is compatible to the RISC-V specifications. For exceptions (like an illegal instruction) this
register provides the address of the exception-causing instruction. For Interrupt (like a machine timer
interrupt) this register provides the address of the next not-yet-executed instruction.
|=======================

:sectnums!:
===== **`mcause`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x342 | **Machine trap cause** | `mcause`
3+| Reset value: _UNDEFINED_
3+| The `mcause` CSR is compatible to the RISC-V specifications. It show the cause ID for a taken exception.
|=======================

.Machine trap cause register
[cols=""^1,^1,<8""]
[options=""header"",grid=""rows""]
|=======================
| Bit  | R/W | Function
| 31   | r/w | **Interrupt**: `1` if the trap is caused by an interrupt (`0` if the trap is caused by an exception)
| 30:5 | r/- | _Reserved_, read as zero
| 4:0  | r/w | **Trap ID**: see <<_neorv32_trap_listing>>
|=======================

:sectnums!:
===== **`mtval`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x343 | **Machine bad address or instruction** | `mtval`
3+| Reset value: _UNDEFINED_
3+| The `mtval` CSR is compatible to the RISC-V specifications. When a trap is triggered, the CSR shows either
the faulting address (for misaligned/faulting load/store/fetch) or the faulting (decompressed) instruction word itself (for illegal
instructions). For all other exceptions (including interrupts) the CSR is set to zero.
|=======================

.Machine bad address or instruction register
[cols=""^5,^5""]
[options=""header"",grid=""rows""]
|=======================
| Trap cause | `mtval` content
| misaligned instruction fetch address or instruction fetch access fault | address of faulting instruction fetch
| misaligned load address, load access fault, misaligned store address or store access fault | program counter (= address) of faulting instruction
| illegal instruction | actual instruction word of faulting instruction (decoded 32-bit instruction word if caused by a compressed instruction)
| anything else including interrupts | _0x00000000_ (always zero)
|=======================

[IMPORTANT]
The NEORV32 `mtval` CSR is read-only. However, a write access will _NOT_ raise an illegal instruction exception.

[NOTE]
In case an invalid compressed instruction raised an illegal instruction exception, `mtval` will show the
according de-compressed instruction word. To get the ""real"" 16-bit instruction that caused the exception
perform a memory load using the address stored in <<_mepc>>.

:sectnums!:
===== **`mip`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x344 | **Machine interrupt Pending** | `mip`
3+| Reset value: _0x00000000_
3+| The `mip` CSR is compatible to the RISC-V specifications and also provides custom extensions. It shows currently _pending_ interrupts.
The bits for the standard RISC-V interrupts are read-only. Hence, these interrupts cannot be cleared using the `mip` register and must
be cleared/acknowledged within the according interrupt-generating device.
The upper 16 bits represent the status of the CPU's fast interrupt request lines (FIRQ). Once triggered, these bit have to be cleared manually by
writing zero to the according `mip` bits (in the interrupt handler routine) to clear the current interrupt request.
|=======================

.Machine interrupt pending register
[cols=""^1,<3,^1,<5""]
[options=""header"",grid=""rows""]
|=======================
| Bit | Name [C] | R/W | Function
| 31:16 | _CSR_MIP_FIRQ15P_ : _CSR_MIP_FIRQ0P_ | r/c | **FIRQxP**: Fast interrupt channel 15..0 pending; cleared request by writing 1
| 11    | _CSR_MIP_MEIP_                       | r/- | **MEIP**: Machine _external_ interrupt pending; _cleared by user-defined mechanism_
| 7     | _CSR_MIP_MTIP_                       | r/- | **MTIP**: Machine _timer_ interrupt pending; cleared by incrementing MTIME's time compare register
| 3     | _CSR_MIP_MSIP_                       | r/- | **MSIP**: Machine _software_ interrupt pending; _cleared by user-defined mechanism_
|=======================

.FIRQ Channel Mapping
[TIP]
See section <<_neorv32_specific_fast_interrupt_requests>> for the mapping of the FIRQ channels and the according
interrupt-triggering processor module.


<<<
// ####################################################################################################################
:sectnums:
==== Machine Physical Memory Protection CSRs

The available physical memory protection logic is configured via the <<_pmp_num_regions>> and
<<_pmp_min_granularity>> top entity generics. <<_pmp_num_regions>> defines the number of implemented
protection regions and thus, the implementation of the available _PMP entries_. Each PMP entry consists of an
8-bit `pmpcfg` CSR entry and a complete `pmpaddr*` CSR.
See section <<_pmp_physical_memory_protection>> for more information.

[NOTE]
If trying to access an PMP-related CSR beyond <<_pmp_num_regions>> **no illegal instruction
exception** is triggered. The according CSRs are read-only (writes are ignored) and always return zero.
However, any access beyond `pmpcfg3` or `pmpaddr15`, which are the last physically implemented registers if
<<_pmp_num_regions>> == 16, will raise an illegal instruction exception as these CSRs are not implemented at all.


:sectnums!:
===== **`pmpcfg`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x3a0 - 0x3a3| **Physical memory protection configuration registers** | `pmpcfg0` - `pmpcfg3`
3+| Reset value: _0x00000000_
3+| The `pmpcfg*` CSRs are compatible to the RISC-V specifications. They are used to configure the protected
regions, where each `pmpcfg*` CSR provides configuration bits for four regions (8-bit per region).
The actual number of available `pmpcfg` CSRs and CSR entries is defined by the <<_pmp_num_regions>> generic.
|=======================

.Physical memory protection configuration register layout (1 entry out of 4)
[cols=""^1,^3,^1,<11""]
[options=""header"",grid=""rows""]
|=======================
| Bit | Name [C] | R/W | Function
| 7   | _PMPCFG_L_     | r/w | **L**: Lock bit, prevents further write accesses, also enforces access rights in machine-mode, can only be cleared by CPU reset
| 6:5 | -              | r/- | _reserved_, read as zero
| 4   | _PMPCFG_A_MSB_ | r/- .2+<| **A**: Mode configuration; only **OFF** (`00`) and **TOR** (`01`) modes are supported, any other value will map back to OFF/TOR
as the MSB is hardwired to zero
| 3   | _PMPCFG_A_LSB_ | r/w 
| 2   | _PMPCFG_X_     | r/w | **X**: Execute permission
| 1   | _PMPCFG_W_     | r/w | **W**: Write permission
| 0   | _PMPCFG_R_     | r/w | **R**: Read permission
|=======================

[WARNING]
Setting the lock bit `L` **only locks the according PMP entry** and not the PMP entries below!


:sectnums!:
===== **`pmpaddr`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x3b0 - 0x3bf| **Physical memory protection address registers** | `pmpaddr0` - `pmpaddr15`
3+| Reset value: _UNDEFINED_
3+| The `pmpaddr*` CSRs are compatible to the RISC-V specifications. They are used to configure bits 33:2 of the PMP region's
physical memory address. The actual number of available `pmpaddr` CSRs is defined by the <<_pmp_num_regions>> generic.
|=======================

.Physical memory protection address register layout
[cols=""^6,^3,<7""]
[options=""header"",grid=""rows""]
|=======================
| Bit                                | R/W | Function
| 31:30                              | r/- | Hardwired to zero
| 29 : _log2(PMP_MIN_GRANULARITY)-2_ | r/w | Bits 31 downto _log2(PMP_MIN_GRANULARITY)_ of the region's address
| _log2(PMP_MIN_GRANULARITY)-2_ : 0  | r/- | Hardwired to zero
|=======================

[NOTE]
When configuring the PMP make sure to set `pmpaddr*` before activating the according region via
`pmpcfg*`. When changing the PMP configuration, deactivate the according region via `pmpcfg*`
before modifying `pmpaddr*`.


<<<
// ####################################################################################################################
:sectnums:
==== (Machine) Counter and Timer CSRs

The (machine) counters and timers are implemented when the `Zicntr` ISA extensions is enabled (default)
via the <<_cpu_extension_riscv_zicntr>> generic.

[NOTE]
The <<_cpu_cnt_width>> generic defines the total size of the CPU's <<_cycleh>> and <<_instreth>>
/ <<_mcycleh>> and <<_minstreth>>
counter CSRs (low and high words combined); the time CSRs are not affected by this generic. Note that any
configuration with <<_cpu_cnt_width>> less than 64 is not RISC-V compliant.

.Effective CPU counter width (`[m]cycle` & `[m]instret`)
[IMPORTANT]
If _CPU_CNT_WIDTH_ is less than 64 (the default value) and greater than or equal 32, the according
MSBs of `[m]cycleh` and `[m]instreth` are read-only and always read as zero. This configuration
will also set the _CSR_MXISA_ZXSCNT_ flag (""small counters"") in the <<_mxisa>> CSR. +
 +
If _CPU_CNT_WIDTH_ is less than 32 and greater than 0, the `[m]cycleh` and `[m]instreth` CSRs are hardwired to zero
and any write access to them is ignored. Furthermore, the according MSBs of `[m]cycle` and `[m]instret` are read-only
and always read as zero. This configuration will also set the _CSR_MXISA_ZXSCNT_ flag (""small counters"") in
the <<_mxisa>> CSR. +
 +
If _CPU_CNT_WIDTH_ is 0, the <<_cycleh>> and <<_instreth>> / <<_mcycleh>> and <<_minstreth>> CSRs are hardwired to zero
and any write access to them is ignored.

.Counter Increment During Debugging
[NOTE]
The `[m]cycle[h]` and `[m]instret[h]` counters do not increment when the CPU is in debug mode.
See section <<_cpu_debug_mode>> for more information.


:sectnums!:
===== **`cycle[h]`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0xc00 | **Cycle counter - low word** | `cycle`
| 0xc80 | **Cycle counter - high word** | `cycleh`
3+| Reset value: _UNDEFINED_
3+| The `cycle[h]` CSR is compatible to the RISC-V specifications. It shows the lower/upper 32-bit of the 64-bit cycle
counter. The `cycle[h]` CSR is a read-only shadowed copy of the `mcycle[h]` CSR.
|=======================


:sectnums!:
===== **`time[h]`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0xc01 | **System time - low word** | `time`
| 0xc81 | **System time - high word** | `timeh`
3+| Reset value: _UNDEFINED_
3+| The `time[h]` CSR is compatible to the RISC-V specifications. It shows the lower/upper 32-bit of the 64-bit system
time. The system time is either generated by the processor-internal _MTIME_ system timer unit (if _IO_MTIME_EN_ = _true_) or can be provided by an
external timer unit via the processor's `mtime_i` signal (if _IO_MTIME_EN_ = _false_).
CSR is read-only. Change the system time via the _MTIME_ unit.
|=======================


:sectnums!:
===== **`instret[h]`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0xc02 | **Instructions-retired counter - low word** | `instret`
| 0xc82 | **Instructions-retired counter - high word** | `instreth`
3+| Reset value: _UNDEFINED_
3+| The `instret[h]` CSR is compatible to the RISC-V specifications. It shows the lower/upper 32-bit of the 64-bit retired
instructions counter. The `instret[h]` CSR is a read-only shadowed copy of the `minstret[h]` CSR.
|=======================


:sectnums!:
===== **`mcycle[h]`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0xb00 | **Machine cycle counter - low word** | `mcycle`
| 0xb80 | **Machine cycle counter - high word** | `mcycleh`
3+| Reset value: _UNDEFINED_
3+| The `mcycle[h]` CSR is compatible to the RISC-V specifications. It shows the lower/upper 32-bit of the 64-bit cycle
counter. The `mcycle[h]` CSR can also be written when in machine mode and is mirrored to the `cycle[h]` CSR.
|=======================


:sectnums!:
===== **`minstret[h]`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0xb02 | **Machine instructions-retired counter - low word** | `minstret`
| 0xb82 | **Machine instructions-retired counter - high word** | `minstreth`
3+| Reset value: _UNDEFINED_
3+| The `minstret[h]` CSR is compatible to the RISC-V specifications. It shows the lower/upper 32-bit of the 64-bit retired
instructions counter. The `minstret[h]` CSR also be written when in machine mode and is mirrored to the `instret[h]` CSR.
|=======================



<<<
// ####################################################################################################################
:sectnums:
==== Hardware Performance Monitors (HPM) CSRs

The hardware performance monitor CSRs are implemented when the `Zihpm` ISA extension is enabled via the
<<_cpu_extension_riscv_zihpm>> generic.

The actual number of implemented hardware performance monitors is configured via the <<_hpm_num_cnts>> top entity generic,
Note that always all 28 HPM counter and configuration registers (`mhpmcounter*[h]` and `mhpmevent*`) are implemented, but
only the actually configured ones are implemented as ""real"" physical registers - the remaining ones will be hardwired to zero.

If trying to access an HPM-related CSR beyond <<_hpm_num_cnts>> **no illegal instruction exception is
triggered**. These CSRs are read-only (writes are ignored) and always return zero.

.Access Privilege
[NOTE]
The HPM system only allows machine-mode access. Hence, `hpmcounter*[h]` CSR are not implemented and any access (even
from machine mode) will raise an illegal instruction exception. Furthermore, the according bits of <<_mcounteren>>
used to configure user-mode access to `hpmcounter*[h]` are hardwired to zero.

The total counter width of the HPMs can be configured before synthesis via the <<_hpm_cnt_width>> generic (0..64-bit).
If <<_hpm_num_cnts>> is less than 64, all remaining MSB-aligned bits are hardwired to zero.

.HPM Counter Overflow
[NOTE]
HPM counters do not saturate and will overflow (restarting at zero).

.Counter Increment
[NOTE]
All HPM counters do not increment when the CPU is either in debug-mode (see section <<_cpu_debug_mode>> for more
information) or when the CPU is in sleep-mode.


:sectnums!:
===== **`mhpmevent`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x232 -0x33f | **Machine hardware performance monitor event selector** | `mhpmevent3` - `mhpmevent31`
3+| Reset value: _UNDEFINED_
3+| The `mhpmevent*` CSRs are compatible to the RISC-V specifications. The value in these CSRs define
the architectural events that cause an increment of the according `mhpmcounter*[h]` counter(s). All available events are
listed in the table below. If more than one event is selected, the according counter will increment if _any_ of
the enabled events is observed (logical OR). Note that the counter will only increment by 1 step per clock
cycle even if more than one trigger event is observed.
|=======================

.HPM Event Select
[cols=""^1,<3,^1,<5""]
[options=""header"",grid=""rows""]
|=======================
| Bit | Name [C]               | R/W | Event
| 0   | _HPMCNT_EVENT_CY_      | r/w | active clock cycle (CPU not in sleep mode)
| 1   | -                      | r/- | _not implemented, always read as zero_
| 2   | _HPMCNT_EVENT_IR_      | r/w | retired instruction (compressed or uncompressed)
| 3   | _HPMCNT_EVENT_CIR_     | r/w | retired compressed instruction
| 4   | _HPMCNT_EVENT_WAIT_IF_ | r/w | instruction fetch memory wait cycle: if more than 1 cycle memory latency, cache miss or high bus traffic
| 5   | _HPMCNT_EVENT_WAIT_II_ | r/w | instruction issue pipeline wait cycle: if more than 1 cycle latency, pipelines flush (like taken branches) / cache miss or high bus traffic
| 6   | _HPMCNT_EVENT_WAIT_MC_ | r/w | multi-cycle ALU operation wait cycle (like iterative shift operation)
| 7   | _HPMCNT_EVENT_LOAD_    | r/w | memory data load operation
| 8   | _HPMCNT_EVENT_STORE_   | r/w | memory data store operation
| 9   | _HPMCNT_EVENT_WAIT_LS_ | r/w | load/store memory wait cycle: if more than 1 cycle memory latency or high bus traffic
| 10  | _HPMCNT_EVENT_JUMP_    | r/w | unconditional jump
| 11  | _HPMCNT_EVENT_BRANCH_  | r/w | conditional branch (_taken_ or _not taken_)
| 12  | _HPMCNT_EVENT_TBRANCH_ | r/w | _taken_ conditional branch
| 13  | _HPMCNT_EVENT_TRAP_    | r/w | entered trap (synchronous exception or interrupt)
| 14  | _HPMCNT_EVENT_ILLEGAL_ | r/w | illegal instruction exception
|=======================

.Cache Misses
[NOTE]
A _miss_ in the instruction cache will cause an automatic reload of the referenced memory block from main
memory. Fetching this block takes several cycles - depending on the configured cache block size and the general
memory system throughput. This will introduce instruction fetch wait cycles (_HPMCNT_EVENT_WAIT_IF_) since the CPU
front end has to wait for the cache to finish loading. Furthermore, this will also introduce instruction issue
wait cycles (_HPMCNT_EVENT_WAIT_II_) as the CPU execution core is waiting for new instructions from the font end.


:sectnums!:
===== **`mhpmcounter[h]`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0xb03 - 0xb1f | **Machine hardware performance monitor - counter low** | `mhpmcounter3` - `mhpmcounter31`
| 0xb83 - 0xb9f | **Machine hardware performance monitor - counter high** | `mhpmcounter3h` - `mhpmcounter31h`
3+| Reset value: _UNDEFINED_
3+| The `mhpmcounter*[h]` CSRs are compatible to the RISC-V specifications. These CSRs provide the lower/upper 32-
bit of arbitrary event counters. The event(s) that trigger an increment of theses counters are selected via the according
`mhpmevent*` CSRs bits.
|=======================


<<<
// ####################################################################################################################
:sectnums:
==== Machine Counter Setup CSRs

:sectnums!:
===== **`mcountinhibit`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x320 | **Machine counter-inhibit register** | `mcountinhibit`
3+| Reset value: _UNDEFINED_
3+| The `mcountinhibit` CSR is compatible to the RISC-V specifications. The bits in this register define which
counter/timer CSR are allowed to perform an automatic increment. Automatic update is enabled if the
according bit in `mcountinhibit` is cleared. The following bits are implemented (all remaining bits are
always zero and are read-only).
|=======================

.Machine counter-inhibit register
[cols=""^1,<3,^1,<5""]
[options=""header"",grid=""rows""]
|=======================
| Bit  | Name [C] | R/W | Event
| 0    | _CSR_MCOUNTINHIBIT_IR_ | r/w | **IR**: The `[m]instret[h]` CSRs will auto-increment with each committed instruction when set
| 2    | _CSR_MCOUNTINHIBIT_CY_ | r/w | **CY**: The `[m]cycle[h]` CSRs will auto-increment with each clock cycle (if CPU is not in sleep state) when set
| 3:31 | _CSR_MCOUNTINHIBIT_HPM3_ : _CSR_MCOUNTINHIBIT_HPM31_ | r/w | **HPMx**: The `mhpmcount*[h]` CSRs will auto-increment according to the configured `mhpmevent*` selector
|=======================


<<<
// ####################################################################################################################
:sectnums:
==== Machine Information CSRs

[NOTE]
All machine information registers can only be accessed in machine mode and are read-only.

:sectnums!:
===== **`mvendorid`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0xf11 | **Machine vendor ID** | `mvendorid`
3+| Reset value: _0x00000000_
3+| The `mvendorid` CSR is compatible to the RISC-V specifications. It is read-only and always reads zero.
|=======================


:sectnums!:
===== **`marchid`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0xf12 | **Machine architecture ID** | `marchid`
3+| Reset value: _0x00000013_
3+| The `marchid` CSR is compatible to the RISC-V specifications. It is read-only and shows the NEORV32
official _RISC-V open-source architecture ID_ (decimal: 19, 32-bit hexadecimal: 0x00000013).
|=======================


:sectnums!:
===== **`mimpid`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0xf13 | **Machine implementation ID** | `mimpid`
3+| Reset value: _defined_
3+| The `mimpid` CSR is compatible to the RISC-V specifications. It is read-only and shows the version of the
NEORV32 as BCD-coded number (example: `mimpid` = _0x01020312_ → 01.02.03.12 → version 1.2.3.12).
|=======================


:sectnums!:
===== **`mhartid`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0xf14 | **Machine hardware thread ID** | `mhartid`
3+| Reset value: _defined_
3+| The `mhartid` CSR is compatible to the RISC-V specifications. It is read-only and shows the core's hart ID,
which is assigned via the CPU's _HW_THREAD_ID_ generic.
|=======================


:sectnums!:
===== **`mconfigptr`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0xf15 | **Machine configuration pointer register** | `mconfigptr`
3+| Reset value: _0x00000000_
3+| This register holds a physical address (if not zero) that points to the base address of an architecture configuration structure.
Software can traverse this data structure to discover information about the harts, the platform, and their configuration.
**NOTE: Not assigned yet.**
|=======================


<<<
// ####################################################################################################################
:sectnums:
==== NEORV32-Specific CSRs

[NOTE]
All NEORV32-specific CSRs are mapped to addresses that are explicitly reserved for custom **Machine-Mode, read-only** CSRs
(assured by the RISC-V privileged specifications). Hence, these CSRs can only be accessed when in machine-mode. Any access
outside of machine-mode will raise an illegal instruction exception.

:sectnums!:
===== **`mxisa`**

[cols=""4,27,>7""]
[frame=""topbot"",grid=""none""]
|=======================
| 0x7c0 | **Machine EXTENDED ISA and Extensions register** | `mxisa`
3+| Reset value: _defined_
3+| NEORV32-specific read-only CSR that helps machine-mode software to discover `Z*` sub-extensions and CPU options.
|=======================


.Machine _EXTENDED_ ISA and Extensions register bits
[cols=""^1,<3,^1,<5""]
[options=""header"",grid=""rows""]
|=======================
| Bit   | Name [C] | R/W | Function
| 31    | _CSR_MXISA_FASTSHIFT_ | r/- | fast shifts available when set (via top's <<_fast_shift_en>> generic)
| 30    | _CSR_MXISA_FASTMUL_   | r/- | fast multiplication available when set (via top's <<_fast_mul_en>> generic)
| 31:22 | -                     | r/- | _reserved_, read as zero
| 21    | _CSR_MXISA_HW_RESET_  | r/- | set if a dedicated hardware reset of all core registers is implemented (via package's `dedicated_reset_c` constant)
| 20    | _CSR_MXISA_IS_SIM_    | r/- | set if CPU is being **simulated** (⚠️ not guaranteed)
| 19:11 | -                     | r/- | _reserved_, read as zero
| 10    | _CSR_MXISA_DEBUGMODE_ | r/- | RISC-V CPU `debug_mode` available when set (via top's <<_on_chip_debugger_en>> generic)
|  9    | _CSR_MXISA_ZIHPM_     | r/- | `Zihpm` (hardware performance monitors) extension available when set (via top's <<_cpu_extension_riscv_zihpm>> generic)
|  8    | _CSR_MXISA_PMP_       | r/- | PMP` (physical memory protection) extension available when set (via top's <<_pmp_num_regions>> generic)
|  7    | _CSR_MXISA_ZICNTR_    | r/- | `Zicntr` extension (`I` sub-extension) available when set - `[m]cycle`, `[m]instret` and `[m]time` CSRs available when set (via top's <<_cpu_extension_riscv_zicntr>> generic)
|  6    | _CSR_MXISA_ZXSCNT_    | r/- | Custom extension - _Small_ CPU counters: `[m]cycle` & `[m]instret` CSRs have less than 64-bit when set (via top's <<_cpu_cnt_width>> generic)
|  5    | _CSR_MXISA_ZFINX_     | r/- | `Zfinx` extension (`F` sub-/alternative-extension: FPU using `x` registers) available when set (via top's <<_cpu_extension_riscv_zfinx>> generic)
|  4    | -                     | r/- | _reserved_, read as zero
|  3    | _CSR_MXISA_ZXCFU_     | r/- | `Zxcfu` extension (custom functions unit for custom RISC-V instructions) available when set (via top's <<_cpu_extension_riscv_zxcfu>> generic)
|  2    | _CSR_MXISA_ZMMUL_     | r/- | `Zmmul` extension (`M` sub-extension) available when set (via top's <<_cpu_extension_riscv_zmmul>> generic)
|  1    | _CSR_MXISA_ZIFENCEI_  | r/- | `Zifencei` extension (`I` sub-extension) available when set (via top's <<_cpu_extension_riscv_zifencei>> generic)
|  0    | _CSR_MXISA_ZICSR_     | r/- | `Zicsr` extension (`I` sub-extension) available when set (via top's <<_cpu_extension_riscv_zicsr>> generic)
|=======================
",12400,True,2629.603835441792,median
"[role=""xpack""]
[[security-settings]]
=== Security settings in {es}
++++
<titleabbrev>Security settings</titleabbrev>
++++

By default, {security} is disabled when you have a basic or trial license. To
enable {security}, use the `xpack.security.enabled` setting.

You configure `xpack.security` settings  to
<<anonymous-access-settings, enable anonymous access>>
and perform message authentication,
<<field-document-security-settings, set up document and field level security>>,
<<realm-settings, configure realms>>,
<<ssl-tls-settings, encrypt communications with SSL>>, and
<<auditing-settings, audit security events>>.

All of these settings can be added to the `elasticsearch.yml` configuration file,
with the exception of the secure settings, which you add to the {es} keystore.
For more information about creating and updating the {es} keystore, see
<<secure-settings>>.

[float]
[[general-security-settings]]
==== General security settings
`xpack.security.enabled`::
Set to `true` to enable {security} on the node. +
+
If set to `false`, which is the default value for basic and trial licenses,
{security} is disabled. It also affects all {kib} instances that connect to this
{es} instance; you do not need to disable {security} in those `kibana.yml` files.
For more information about disabling {security} in specific {kib} instances, see  {kibana-ref}/security-settings-kb.html[{kib} security settings].

`xpack.security.hide_settings`::
A comma-separated list of settings that are omitted from the results of the
<<cluster-nodes-info,cluster nodes info API>>. You can use wildcards to include
multiple settings in the list.  For example, the following value hides all the
settings for the ad1 realm: `xpack.security.authc.realms.ad1.*`. The API already
omits all `ssl` settings, `bind_dn`, and `bind_password` due to the
sensitive nature of the information.

[float]
[[password-security-settings]]
==== Default password security settings
`xpack.security.authc.accept_default_password`::
In `elasticsearch.yml`, set this to `false` to disable support for the default ""changeme"" password.

[float]
[[anonymous-access-settings]]
==== Anonymous access settings
You can configure the following anonymous access settings in
`elasticsearch.yml`.  For more information, see {xpack-ref}/anonymous-access.html[
Enabling anonymous access].

`xpack.security.authc.anonymous.username`::
The username (principal) of the anonymous user. Defaults to `_es_anonymous_user`.

`xpack.security.authc.anonymous.roles`::
The roles to associate with the anonymous user. Required.

`xpack.security.authc.anonymous.authz_exception`::
When `true`, an HTTP 403 response is returned if the anonymous user
does not have the appropriate permissions for the requested action. The
user is not prompted to provide credentials to access the requested
resource. When set to `false`, a HTTP 401 is returned and the user
can provide credentials with the appropriate permissions to gain
access. Defaults to `true`.

[float]
[[field-document-security-settings]]
==== Document and field level security settings

You can set the following document and field level security
settings in `elasticsearch.yml`. For more information, see
{xpack-ref}/field-and-document-access-control.html[Setting up document and field
level security].

`xpack.security.dls_fls.enabled`::
Set to `false` to prevent document and field level security
from being configured. Defaults to `true`.

[float]
[[token-service-settings]]
==== Token service settings

You can set the following token service settings in
`elasticsearch.yml`.

`xpack.security.authc.token.enabled`::
Set to `false` to disable the built-in token service. Defaults to `true` unless
 `xpack.security.http.ssl.enabled` is `false`. This prevents sniffing the token
  from a connection over plain http.

`xpack.security.authc.token.timeout`::
The length of time that a token is valid for. By default this value is `20m` or
20 minutes. The maximum value is 1 hour.

[float]
[[realm-settings]]
==== Realm settings
You configure realm settings in the `xpack.security.authc.realms`
namespace in `elasticsearch.yml`. For example:

[source,yaml]
----------------------------------------
xpack.security.authc.realms:

    realm1:
        type: native
        order: 0
        ...

    realm2:
        type: ldap
        order: 1
        ...

    realm3:
        type: active_directory
        order: 2
        ...
    ...
----------------------------------------

The valid settings vary depending on the realm type. For more
information, see {xpack-ref}/setting-up-authentication.html[Setting up authentication].

[float]
[[ref-realm-settings]]
===== Settings valid for all realms

`type`::
The type of the realm: `native, `ldap`, `active_directory`, `pki`, or `file`. Required.

`order`::
The priority of the realm within the realm chain. Realms with a lower order are
consulted first. Although not required, use of this setting is strongly
recommended when you configure multiple realms. Defaults to `Integer.MAX_VALUE`.

`enabled`::
Indicates whether a realm is enabled. You can use this setting to disable a
realm without removing its configuration information. Defaults to `true`.

[[ref-native-settings]]
[float]
===== Native realm settings

For a native realm, the `type` must be set to `native`. In addition to the 
<<ref-realm-settings,settings that are valid for all realms>>, you can specify  
the following optional settings: 

`cache.ttl`:: The time-to-live for cached user entries. A user and a hash of its 
credentials are cached for this period of time. Specify the time period using 
the standard {es} <<time-units,time units>>. Defaults to `20m`.

`cache.max_users`:: The maximum number of user entries that can live in the 
cache at any given time. Defaults to 100,000.

`cache.hash_algo`:: (Expert Setting) The hashing algorithm that is used for the 
in-memory cached user credentials. For possible values, see 
{xpack-ref}/controlling-user-cache.html[Cache hash algorithms]. Defaults to 
`ssha256`.


[[ref-users-settings]]

[float]
===== File realm settings

The `type` setting must be set to `file`. In addition to the 
<<ref-realm-settings,settings that are valid for all realms>>, you can specify  
the following settings: 

`cache.ttl`::
The time-to-live for cached user entries. A user and a hash of its credentials 
are cached for this configured period of time. Defaults to `20m`. Specify values 
using the standard {es} {ref}/common-options.html#time-units[time units].
Defaults to `20m`.

`cache.max_users`::
The maximum number of user entries that can live in the cache at a given time.
Defaults to 100,000.

`cache.hash_algo`::
(Expert Setting) The hashing algorithm that is used for the in-memory cached
user credentials. See the {xpack-ref}/controlling-user-cache.html#controlling-user-cache[Cache hash algorithms] table for
all possible values. Defaults to `ssha256`.

[[ref-ldap-settings]]
[float]
===== LDAP realm settings

The `type` setting must be set to `ldap`. In addition to the 
<<ref-realm-settings>>, you can specify the following settings: 

`url`:: Specifies one or more LDAP URLs in the format  
`ldap[s]://<server>:<port>`. Multiple URLs can be defined using a comma 
separated value or array syntax: `[ ""ldaps://server1:636"", ""ldaps://server2:636"" ]`. 
`ldaps` and `ldap` URL protocols cannot be mixed in the same realm. Required.

`load_balance.type`::
The behavior to use when there are multiple LDAP URLs defined. For supported
values see <<load-balancing,load balancing and failover types>>.
Defaults to `failover`.

`load_balance.cache_ttl`::
When using `dns_failover` or `dns_round_robin` as the load balancing type,
this setting controls the amount of time to cache DNS lookups. Defaults
to `1h`.

`bind_dn`::
The DN of the user that is used to bind to the LDAP and perform searches.
Only applicable in user search mode.
If not specified, an anonymous bind is attempted.
Defaults to Empty. Due to its potential security impact, `bind_dn` is not 
exposed via the <<cluster-nodes-info,nodes info API>>.

`bind_password`::
deprecated[6.3] Use `secure_bind_password` instead. The password for the user 
that is used to bind to the LDAP directory.
Defaults to Empty. Due to its potential security impact, `bind_password` is not 
exposed via the <<cluster-nodes-info,nodes info API>>.


`secure_bind_password` (<<secure-settings,Secure>>)::
The password for the user that is used to bind to the LDAP directory.
Defaults to Empty.

`user_dn_templates`::
The DN template that replaces the user name with the string `{0}`.
This setting is multivalued; you can specify multiple user contexts.
Required to operate in user template mode. If `user_search.base_dn` is specified, 
this setting is not valid. For more information on
the different modes, see {xpack-ref}/ldap-realm.html[LDAP realms].
+
--
NOTE: If any settings starting with `user_search` are specified, the 
`user_dn_templates` settings are ignored.

--

`user_group_attribute`::
Specifies the attribute to examine on the user for group membership.
If any `group_search` settings are specified, this setting is ignored. Defaults 
to `memberOf`.

`user_search.base_dn`::
Specifies a container DN to search for users. Required
to operated in user search mode. If `user_dn_templates` is specified, this 
setting is not valid. For more information on
the different modes, see {xpack-ref}/ldap-realm.html[LDAP realms].

`user_search.scope`::
The scope of the user search. Valid values are `sub_tree`, `one_level` or
`base`. `one_level` only searches objects directly contained within the
`base_dn`. `sub_tree` searches all objects contained under `base_dn`.
`base` specifies that the `base_dn` is the user object, and that it is
the only user considered. Defaults to  `sub_tree`.

`user_search.filter`::
Specifies the filter used to search the directory in attempts to match
an entry with the username provided by the user. Defaults to `(uid={0})`.
`{0}` is substituted with the username provided when searching.

`user_search.attribute`::
deprecated[5.6] Use `user_search.filter` instead.
The attribute to match with the username sent with the request. Defaults to `uid`.

`user_search.pool.enabled`::
Enables or disables connection pooling for user search. If set to `false`, a new 
connection is created for every search. The
default is `true` when `bind_dn` is set.

`user_search.pool.size`::
The maximum number of connections to the LDAP server to allow in the
connection pool. Defaults to `20`.

`user_search.pool.initial_size`::
The initial number of connections to create to the LDAP server on startup.
Defaults to `0`. If the LDAP server is down, values greater than `0` could cause 
startup failures.

`user_search.pool.health_check.enabled`::
Enables or disables a health check on LDAP connections in the connection
pool. Connections are checked in the background at the specified interval.
Defaults to `true`.

`user_search.pool.health_check.dn`::
The distinguished name that is retrieved as part of the health check.
Defaults to the value of `bind_dn` if present; if
not, falls back to `user_search.base_dn`.

`user_search.pool.health_check.interval`::
The interval to perform background checks of connections in the pool.
Defaults to `60s`.

`group_search.base_dn`::
The container DN to search for groups in which the user has membership. When
this element is absent, {security} searches for the attribute specified by
`user_group_attribute` set on the user in order to determine group membership.

`group_search.scope`::
Specifies whether the group search should be `sub_tree`, `one_level` or
`base`.  `one_level` only searches objects directly contained within the
`base_dn`. `sub_tree` searches all objects contained under `base_dn`.
`base` specifies that the `base_dn` is a group object, and that it is the
only group considered. Defaults to  `sub_tree`.

`group_search.filter`:: 
Specifies a filter to use to look up a group. 
When not set, the realm searches for `group`, `groupOfNames`, `groupOfUniqueNames`,
or `posixGroup` with the attributes `member`, `memberOf`, or `memberUid`.  Any
instance of `{0}` in the filter is replaced by the user attribute defined in
`group_search.user_attribute`.

`group_search.user_attribute`::
Specifies the user attribute that is fetched and provided as a parameter to
the filter.  If not set, the user DN is passed into the filter. Defaults to Empty.

`unmapped_groups_as_roles`::
If set to `true`, the names of any unmapped LDAP groups are used as role names 
and assigned to the user. A group is considered to be _unmapped_ if it is not 
not referenced in a 
{xpack-ref}/mapping-roles.html#mapping-roles-file[role-mapping file]. API-based 
role mappings are not considered. Defaults to `false`.

`files.role_mapping`::
The {xpack-ref}/security-files.html[location] for the {xpack-ref}/mapping-roles.html#mapping-roles[
YAML role mapping configuration file]. Defaults to
`CONFIG_DIR/role_mapping.yml`.

`follow_referrals`::
Specifies whether {security} should follow referrals returned
by the LDAP server. Referrals are URLs returned by the server that are to be
used to continue the LDAP operation (for example, search). Defaults to `true`.

`metadata`::
A list of additional LDAP attributes that should be loaded from the
LDAP server and stored in the authenticated user's metadata field.

`timeout.tcp_connect`::
The TCP connect timeout period for establishing an LDAP connection.
An `s` at the end indicates seconds, or `ms` indicates milliseconds.
Defaults to `5s` (5 seconds ).

`timeout.tcp_read`::
The TCP read timeout period after establishing an LDAP connection.
An `s` at the end indicates seconds, or `ms` indicates milliseconds.
Defaults to `5s` (5 seconds ).

`timeout.ldap_search`::
The LDAP Server enforced timeout period for an LDAP search.
An `s` at the end indicates seconds, or `ms` indicates milliseconds.
Defaults to `5s` (5 seconds ).

`ssl.key`::
Path to a PEM encoded file containing the private key, which is used if the 
LDAP server requires client authentication. `ssl.key` and `ssl.keystore.path` 
cannot be used at the same time.

`ssl.key_passphrase`::
The passphrase that is used to decrypt the private key. This value is
optional as the key may not be encrypted.

`ssl.secure_key_passphrase` (<<secure-settings,Secure>>)::
The passphrase that is used to decrypt the private key.

`ssl.certificate`::
Path to a PEM encoded file containing the certificate (or certificate chain)
that will be presented to clients when they connect.

`ssl.certificate_authorities`::
List of paths to PEM encoded certificate files that should be trusted. 
`ssl.certificate_authorities` and `ssl.truststore.path` cannot be used at the 
same time.

`ssl.keystore.path`::
The path to the Java Keystore file that contains a private key and certificate.
`ssl.key` and `ssl.keystore.path` may not be used at the same time.

`ssl.keystore.type`::
The format of the keystore file. Should be either `jks` to use the Java
Keystore format, or `PKCS12` to use PKCS#12 files. The default is `jks`.

`ssl.keystore.password`::
The password to the keystore.

`ssl.keystore.secure_password` (<<secure-settings,Secure>>)::
The password to the keystore.

`ssl.keystore.key_password`::
The password for the key in the keystore. Defaults to the keystore password.

`ssl.keystore.secure_key_password`::
The password for the key in the keystore. Defaults to the keystore password.

`ssl.truststore.path`::
The path to the Java Keystore file that contains the certificates to trust.
`ssl.certificate_authorities` and `ssl.truststore.path` cannot be used at the same time.

`ssl.truststore.password`::
The password to the truststore.

`ssl.truststore.secure_password` (<<secure-settings,Secure>>)::
The password to the truststore.

`ssl.truststore.type`::
The format of the keystore file. Should be either `jks` to use the Java
Keystore format, or `PKCS12` to use PKCS#12 files. The default is `jks`.

`ssl.verification_mode`::
Indicates the type of verification when using `ldaps` to protect against man
in the middle attacks and certificate forgery. Values are `none`, `certificate`,
and `full`. Defaults to the value of `xpack.ssl.verification_mode`.
+
See <<ssl-tls-settings,`xpack.ssl.verification_mode`>> for an explanation of
these values.

`ssl.supported_protocols`::
Supported protocols for TLS/SSL (with versions). Defaults to the value of
`xpack.ssl.supported_protocols`.

`ssl.cipher_suites`:: Specifies the cipher suites that should be supported when 
communicating with the LDAP server. 
Supported cipher suites can be found in Oracle's http://docs.oracle.com/javase/8/docs/technotes/guides/security/SunProviders.html[
Java Cryptography Architecture documentation]. Defaults to the value of
`xpack.ssl.cipher_suites`.

`cache.ttl`::
Specifies the time-to-live for cached user entries. A user and a hash of its 
credentials are cached for this period of time. Use the standard {es}
<<time-units,time units>>. Defaults to  `20m`.

`cache.max_users`::
Specifies the maximum number of user entries that the cache can contain.
Defaults to `100000`.

`cache.hash_algo`::
(Expert Setting) Specifies the hashing algorithm that is used for the
in-memory cached user credentials. See {xpack-ref}/controlling-user-cache.html#controlling-user-cache[Cache hash algorithms]
table for all possible values. Defaults to `ssha256`.

[[ref-ad-settings]]
[float]
===== Active Directory realm settings

The `type` setting must be set to `active_directory`. In addition to the 
<<ref-realm-settings,settings that are valid for all realms>>, you can specify  
the following settings: 

`url`::
An LDAP URL of the form `ldap[s]://<server>:<port>`. {security} attempts to 
authenticate against this URL. If the URL is not specified, it is derived from 
the `domain_name` setting and assumes an unencrypted connection to port 389. 
Defaults to `ldap://<domain_name>:389`. This setting is required when connecting 
using SSL/TLS or when using a custom port.

`load_balance.type`::
The behavior to use when there are multiple LDAP URLs defined. For supported
values see <<load-balancing,load balancing and failover types>>.
Defaults to `failover`.

`load_balance.cache_ttl`::
When using `dns_failover` or `dns_round_robin` as the load balancing type,
this setting controls the amount of time to cache DNS lookups. Defaults
to `1h`.

`domain_name`::
The domain name of Active Directory. If the the `url` and `user_search_dn` 
settings are not specified, the cluster can derive those values from this 
setting. Required.

`bind_dn`::
The DN of the user that is used to bind to Active Directory and perform searches.
Defaults to Empty. Due to its potential security impact, `bind_dn` is not 
exposed via the <<cluster-nodes-info,nodes info API>>.

`bind_password`::
deprecated[6.3] Use `secure_bind_password` instead. The password for the user 
that is used to bind to Active Directory. Defaults to Empty. Due to its 
potential security impact, `bind_password` is not exposed via the 
<<cluster-nodes-info,nodes info API>>.

`secure_bind_password` (<<secure-settings,Secure>>)::
The password for the user that is used to bind to Active Directory.
Defaults to Empty.

`unmapped_groups_as_roles`::
If set to `true`, the names of any unmapped Active Directory groups are used as 
role names and assigned to the user. A group is considered _unmapped_ when it 
is not referenced in any role-mapping files. API-based role mappings are not 
considered. Defaults to `false`.

`files.role_mapping`::
The {xpack-ref}/security-files.html[location] for the YAML
role mapping configuration file. Defaults to `CONFIG_DIR/role_mapping.yml`.

`user_search.base_dn`::
The context to search for a user. Defaults to the root
of the Active Directory domain.

`user_search.scope`::
Specifies whether the user search should be `sub_tree`, `one_level` or `base`.
`one_level` only searches users directly contained within the `base_dn`.
`sub_tree` searches all objects contained under `base_dn`. `base`
specifies that the `base_dn` is a user object, and that it is the
only user considered. Defaults to `sub_tree`.

`user_search.filter`::
Specifies a filter to use to lookup a user given a username.  The default
filter looks up `user` objects with either `sAMAccountName` or
`userPrincipalName`. If specified, this must be a valid LDAP user search filter. 
For example `(&(objectClass=user)(sAMAccountName={0}))`. For more information, 
see 
https://msdn.microsoft.com/en-us/library/aa746475(v=vs.85).aspx[Search Filter Syntax].

`user_search.upn_filter`::
Specifies a filter to use to lookup a user given a user principal name.
The default filter looks up `user` objects with
a matching `userPrincipalName`. If specified, this
must be a valid LDAP user search filter. For example,
`(&(objectClass=user)(userPrincipalName={1}))`. `{1}` is the full user principal name
provided by the user. For more information, see 
https://msdn.microsoft.com/en-us/library/aa746475(v=vs.85).aspx[Search Filter Syntax].

`user_search.down_level_filter`::
Specifies a filter to use to lookup a user given a down level logon name
(DOMAIN\\user). The default filter looks up `user` objects with a matching
`sAMAccountName` in the domain provided. If specified, this
must be a valid LDAP user search filter. For example,
`(&(objectClass=user)(sAMAccountName={0}))`. For more information, see 
https://msdn.microsoft.com/en-us/library/aa746475(v=vs.85).aspx[Search Filter Syntax]. 

`user_search.pool.enabled`::
Enables or disables connection pooling for user search. When
disabled a new connection is created for every search. The
default is `true` when `bind_dn` is provided.

`user_search.pool.size`::
The maximum number of connections to the Active Directory server to allow in the
connection pool. Defaults to `20`.

`user_search.pool.initial_size`::
The initial number of connections to create to the Active Directory server on startup.
Defaults to `0`. If the LDAP server is down, values greater than 0 
could cause startup failures. 

`user_search.pool.health_check.enabled`::
Enables or disables a health check on Active Directory connections in the connection
pool. Connections are checked in the background at the specified interval.
Defaults to `true`.

`user_search.pool.health_check.dn`::
The distinguished name to be retrieved as part of the health check.
Defaults to the value of `bind_dn` if that setting is present. Otherwise, it 
defaults to the value of the `user_search.base_dn` setting. 

`user_search.pool.health_check.interval`::
The interval to perform background checks of connections in the pool.
Defaults to `60s`.

`group_search.base_dn`::
The context to search for groups in which the user has membership.  Defaults
to the root of the Active Directory domain.

`group_search.scope`::
Specifies whether the group search should be `sub_tree`, `one_level` or
`base`.  `one_level` searches for groups directly contained within the
`base_dn`. `sub_tree` searches all objects contained under `base_dn`.
`base` specifies that the `base_dn` is a group object, and that it is
the only group considered. Defaults to `sub_tree`.

`metadata`::
A list of additional LDAP attributes that should be loaded from the
LDAP server and stored in the authenticated user's metadata field.

`timeout.tcp_connect`::
The TCP connect timeout period for establishing an LDAP connection.
An `s` at the end indicates seconds, or `ms` indicates milliseconds.
Defaults to `5s` (5 seconds ).

`timeout.tcp_read`::
The TCP read timeout period after establishing an LDAP connection.
An `s` at the end indicates seconds, or `ms` indicates milliseconds.
Defaults to `5s` (5 seconds ).

`timeout.ldap_search`::
The LDAP Server enforced timeout period for an LDAP search.
An `s` at the end indicates seconds, or `ms` indicates milliseconds.
Defaults to `5s` (5 seconds ).

`ssl.certificate`::
Path to a PEM encoded file containing the certificate (or certificate chain)
that will be presented to clients when they connect. 

`ssl.certificate_authorities`::
List of paths to PEM encoded certificate files that should be trusted. 
`ssl.certificate_authorities` and `ssl.truststore.path` cannot be used at the 
same time.

`ssl.key`::
Path to the PEM encoded file containing the private key, which is used when the 
Active Directory server requires client authentication. `ssl.key` and 
`ssl.keystore.path` cannot be used at the same time.


`ssl.key_passphrase`::
The passphrase that is used to decrypt the private key. This value is
optional as the key might not be encrypted.

`ssl.secure_key_passphrase` (<<secure-settings,Secure>>)::
The passphrase that is used to decrypt the private key. This value is
optional as the key might not be encrypted.

`ssl.keystore.key_password`::
The password for the key in the keystore. Defaults to the keystore password.

`ssl.keystore.secure_key_password` (<<secure-settings,Secure>>)::
The password for the key in the keystore. Defaults to the keystore password.

`ssl.keystore.password`::
The password to the keystore.

`ssl.secure_keystore.password` (<<secure-settings,Secure>>)::
The password to the keystore.

`ssl.keystore.path`::
The path to the Java Keystore file that contains a private key and certificate.
`ssl.key` and `ssl.keystore.path` cannot be used at the same time.

`ssl.keystore.type`::
The format of the keystore file. Should be either `jks` to use the Java
Keystore format, or `PKCS12` to use PKCS#12 files. The default is `jks`.

`ssl.truststore.password`::
The password to the truststore.

`ssl.truststore.secure_password` (<<secure-settings,Secure>>)::
The password to the truststore.

`ssl.truststore.path`::
The path to the Java Keystore file that contains the certificates to trust.
`ssl.certificate_authorities` and `ssl.truststore.path` cannot be used at the 
same time.

`ssl.truststore.type`::
The format of the truststore file. Should be either `jks` to use the Java
Keystore format, or `PKCS12` to use PKCS#12 files. The default is `jks`.

`ssl.verification_mode`::
Indicates the type of verification when using `ldaps` to protect against man
in the middle attacks and certificate forgery. Values are `none`, `certificate`,
and `full`. Defaults to the value of `xpack.ssl.verification_mode`.
+
See <<ssl-tls-settings,`xpack.ssl.verification_mode`>> for an explanation of
these values.

`ssl.supported_protocols`::
Supported protocols for TLS/SSL (with versions). Defaults to the value of
`xpack.ssl.supported_protocols`.

`ssl.cipher_suites`:: Specifies the cipher suites that should be supported when 
communicating with the Active Directory server. 
Supported cipher suites can be found in Oracle's http://docs.oracle.com/javase/8/docs/technotes/guides/security/SunProviders.html[
Java Cryptography Architecture documentation]. Defaults to the value of
`xpack.ssl.cipher_suites`.

`cache.ttl`::
Specifies the time-to-live for cached user entries. A user and a hash of its 
credentials are cached for this configured period of time. Use the
standard Elasticsearch {ref}/common-options.html#time-units[time units]).
Defaults to `20m`.

`cache.max_users`::
Specifies the maximum number of user entries that the cache can contain.
Defaults to `100000`.

`cache.hash_algo`::
(Expert Setting) Specifies the hashing algorithm that is used for
the in-memory cached user credentials (see {xpack-ref}/controlling-user-cache.html#controlling-user-cache[Cache hash algorithms] table for all possible values). Defaults to `ssha256`.

`follow_referrals`::
If set to `true` {security} follows referrals returned by the LDAP server. 
Referrals are URLs returned by the server that are to be used to continue the 
LDAP operation (such as `search`). Defaults to `true`.

[[ref-pki-settings]]
[float]
===== PKI realm settings

The `type` setting must be set to `pki`. In addition to the 
<<ref-realm-settings,settings that are valid for all realms>>, you can specify  
the following settings: 

`username_pattern`::
The regular expression pattern used to extract the username from the
certificate DN. The first match group is the used as the username.
Defaults to `CN=(.*?)(?:,\\|$)`.

`certificate_authorities`::
List of paths to the PEM certificate files that should be used to authenticate a
user's certificate as trusted. Defaults to the trusted certificates configured
for SSL. This setting cannot be used with `truststore.path`. 

`truststore.algorithm`::
Algorithm for the truststore. Defaults to `SunX509`.

`truststore.password`::
The password for the truststore. Must be provided if `truststore.path` is set.

`truststore.secure_password` (<<secure-settings,Secure>>)::
The password for the truststore.

`truststore.path`::
The path of a truststore to use. Defaults to the trusted certificates configured
for SSL. This setting cannot be used with `certificate_authorities`.

`files.role_mapping`::
Specifies the {xpack-ref}/security-files.html[location] of the
{xpack-ref}/mapping-roles.html[YAML role  mapping configuration file].
Defaults to `CONFIG_DIR/role_mapping.yml`.

`cache.ttl`::
Specifies the time-to-live for cached user entries. A user and a hash of its 
credentials are cached for this period of time. Use the
standard {es} {ref}/common-options.html#time-units[time units]).
Defaults to `20m`.

`cache.max_users`::
Specifies the maximum number of user entries that the cache can contain.
Defaults to `100000`.

[[ref-saml-settings]]
[float]
===== SAML realm settings

The `type` setting must be set to `saml`. In addition to the 
<<ref-realm-settings,settings that are valid for all realms>>, you can specify  
the following settings: 

`idp.entity_id`::
The Entity ID of the SAML Identity Provider. An Entity ID is a URI with a 
maximum length of 1024 characters. It can be a URL (https://idp.example.com/) or 
a URN (`urn:example.com:idp`) and can be found in the configuration or the SAML 
metadata of the Identity Provider.

`idp.metadata.path`::
The path _(recommended)_ or URL to a SAML 2.0 metadata file describing the
capabilities and configuration of the Identity Provider.
If a path is provided, then it is resolved relative to the {es} config
directory.
If a URL is provided, then it must be either a `file` URL or a `https` URL.
{security} automatically polls this metadata resource and reloads 
the IdP configuration when changes are detected.
File based resources are polled at a frequency determined by the global {es}
`resource.reload.interval.high` setting, which defaults to 5 seconds.
HTTPS resources are polled at a frequency determined by the realm's
`idp.metadata.http.refresh` setting.

`idp.metadata.http.refresh`::
Controls the frequency with which `https` metadata is checked for changes.
Defaults to `1h` (1 hour).

`idp.use_single_logout`::
Indicates whether to utilise the Identity Provider's Single Logout service
(if one exists in the IdP metadata file).
Defaults to `true`.

`sp.entity_id`::
The Entity ID to use for this SAML Service Provider. This should be entered as a 
URI. We recommend that you use the base URL of your Kibana instance. For example, 
`https://kibana.example.com/`. 

`sp.acs`::
The URL of the Assertion Consumer Service within {kib}. Typically this is the 
""api/security/v1/saml"" endpoint of your Kibana server. For example, 
`https://kibana.example.com/api/security/v1/saml`. 

`sp.logout`::
The URL of the Single Logout service within {kib}. Typically this is the 
""logout"" endpoint of your Kibana server. For example, 
`https://kibana.example.com/logout`.

`attributes.principal`::
The Name of the SAML attribute that should be used as the {security} user's
principal (username).

`attributes.groups`::
The Name of the SAML attribute that should be used to populate {security}
user's groups. 

`attributes.name`::
The Name of the SAML attribute that should be used to populate {security}
user's full name. 

`attributes.mail`::
The Name of the SAML attribute that should be used to populate {security}
user's email address. 

`attributes.dn`::
The Name of the SAML attribute that should be used to populate {security}
user's X.500 _Distinguished Name_. 

`attribute_patterns.principal`::
A Java regular expression that is matched against the SAML attribute specified
by `attributes.pattern` before it is applied to the user's _principal_ property.
The attribute value must match the pattern and the value of the first
_capturing group_ is used as the principal. For example, `^([^@]+)@example\\\\.com$` 
matches email addresses from the ""example.com"" domain and uses the local-part as 
the principal.

`attribute_patterns.groups`::
As per `attribute_patterns.principal`, but for the _group_ property.

`attribute_patterns.name`::
As per `attribute_patterns.principal`, but for the _name_ property.

`attribute_patterns.mail`::
As per `attribute_patterns.principal`, but for the _mail_ property.

`attribute_patterns.dn`::
As per `attribute_patterns.principal`, but for the _dn_ property.

`nameid_format`::
The NameID format that should be requested when asking the IdP to authenticate
the current user. Defaults to requesting _transient_ names 
(`urn:oasis:names:tc:SAML:2.0:nameid-format:transient`). 

`nameid.allow_create`:: The value of the `AllowCreate` attribute of the 
`NameIdPolicy` element in an authentication request. Defaults to `false`. 

`nameid.sp_qualifier`:: The value of the `SPNameQualifier` attribute of the 
`NameIdPolicy` element in an authentication request. The default is to not 
include the `SPNameQualifier` attribute.

`force_authn`::
Specifies whether to set the `ForceAuthn` attribute when requesting that the IdP
authenticate the current user. If set to `true`, the IdP is required to verify 
the user’s identity, irrespective of any existing sessions they might have. 
Defaults to `false`.

`populate_user_metadata`::
Specifies whether to populate the {es} user's metadata with the values that are 
provided by the SAML attributes. Defaults to `true`.

`allowed_clock_skew`::
The maximum amount of skew that can be tolerated between the IdP's clock and the
{es} node's clock.
Defaults to `3m` (3 minutes).

[float]
[[ref-saml-signing-settings]]
===== SAML realm signing settings

If a signing key is configured (that is, either `signing.key` or 
`signing.keystore.path` is set), then {security} signs outgoing SAML messages. 
Signing can be configured using the following settings:

`signing.saml_messages`::
A list of SAML message types that should be signed or `*` to sign all messages.
Each element in the list should be the local name of a SAML XML Element.
Supported element types are `AuthnRequest`, `LogoutRequest` and `LogoutResponse`.
Only valid if `signing.key` or `signing.keystore.path` is also specified.
Defaults to `*`.

`signing.key`::
Specifies the path to the PEM encoded private key to use for SAML message signing.
`signing.key` and `signing.keystore.path` cannot be used at the same time.

`signing.secure_key_passphrase` (<<secure-settings,Secure>>)::
Specifies the passphrase to decrypt the PEM encoded private key (`signing.key`)
if it is encrypted.

`signing.certificate`::
Specifies the path to the PEM encoded certificate (or certificate chain) that 
corresponds to the `signing.key`. This certificate must also be included in the 
Service Provider metadata or manually configured within the IdP to allow for 
signature validation. This setting can only be used if `signing.key` is set.

`signing.keystore.path`::
The path to the keystore that contains a private key and certificate.
Must be either a Java Keystore (jks) or a PKCS#12 file.
`signing.key` and `signing.keystore.path` cannot be used at the same time.

`signing.keystore.type`::
The type of the keystore in `signing.keystore.path`.
Must be either `jks` or `PKCS12`. If the keystore path ends in "".p12"", "".pfx"", 
or ""pkcs12"", this setting defaults to `PKCS12`. Otherwise, it defaults to `jks`.

`signing.keystore.alias`::
Specifies the alias of the key within the keystore that should be
used for SAML message signing. If the keystore contains more than one private 
key, this setting must be specified. 

`signing.keystore.secure_password` (<<secure-settings,Secure>>)::
The password to the keystore in `signing.keystore.path`.

`signing.keystore.secure_key_password` (<<secure-settings,Secure>>)::
The password for the key in the keystore (`signing.keystore.path`).
Defaults to the keystore password.

[float]
[[ref-saml-encryption-settings]]
===== SAML realm encryption settings

If an encryption key is configured (that is, either `encryption.key` or 
`encryption.keystore.path` is set), then {security} publishes an encryption 
certificate when generating metadata and attempts to decrypt incoming SAML 
content. Encryption can be configured using the following settings:

`encryption.key`::
Specifies the path to the PEM encoded private key to use for SAML message
decryption.
`encryption.key` and `encryption.keystore.path` cannot be used at the same time.

`encryption.secure_key_passphrase` (<<secure-settings,Secure>>)::
Specifies the passphrase to decrypt the PEM encoded private key
(`encryption.key`) if it is encrypted.

`encryption.certificate`::
Specifies the path to the PEM encoded certificate (or certificate chain) that is 
associated with the `encryption.key`. This certificate must also be included in 
the Service Provider metadata or manually configured within the IdP to enable 
message encryption. This setting can be used only if `encryption.key` is set.

`encryption.keystore.path`::
The path to the keystore that contains a private key and certificate.
Must be either a Java Keystore (jks) or a PKCS#12 file.
`encryption.key` and `encryption.keystore.path` cannot be used at the same time.

`encryption.keystore.type`::
The type of the keystore (`encryption.keystore.path`).
Must be either `jks` or `PKCS12`. If the keystore path ends in "".p12"", "".pfx"", 
or ""pkcs12"", this setting defaults to `PKCS12`. Otherwise, it defaults to `jks`.

`encryption.keystore.alias`::
Specifies the alias of the key within the keystore (`encryption.keystore.path`)
that should be used for SAML message decryption. If not specified, all compatible
key pairs from the keystore are considered as candidate keys for decryption.

`encryption.keystore.secure_password` (<<secure-settings,Secure>>)::
The password to the keystore (`encryption.keystore.path`).

`encryption.keystore.secure_key_password` (<<secure-settings,Secure>>)::
The password for the key in the keystore (`encryption.keystore.path`). Only a
single password is supported. If you are using multiple decryption keys, 
they cannot have individual passwords.

[float]
[[ref-saml-ssl-settings]]
===== SAML realm SSL settings

If you are loading the IdP metadata over SSL/TLS (that is, `idp.metadata.path` 
is a URL using the `https` protocol), the following settings can be used to 
configure SSL. If these are not specified, then the 
<<ssl-tls-settings,default SSL settings>> are used.

NOTE: These settings are not used for any purpose other than loading metadata 
over https.

`ssl.key`::
Specifies the path to the PEM encoded private key to use for http client 
authentication (if required). `ssl.key` and `ssl.keystore.path` cannot be used 
at the same time.

`ssl.key_passphrase`::
Specifies the
passphrase to decrypt the PEM encoded private key (`ssl.key`) if it is
encrypted. Cannot be used with `ssl.secure_key_passphrase`. 

`ssl.secure_key_passphrase` (<<secure-settings,Secure>>)::
Specifies the
passphrase to decrypt the PEM encoded private key (`ssl.key`) if it is
encrypted. Cannot be used with `ssl.key_passphrase`. 

`ssl.certificate`::
Specifies the
path to the PEM encoded certificate (or certificate chain) that is associated
with the key (`ssl.key`). This setting can be used only if `ssl.key` is set.

`ssl.certificate_authorities`::
Specifies the
paths to the PEM encoded certificate authority certificates that should be
trusted. `ssl.certificate_authorities` and `ssl.truststore.path` cannot be
used at the same time.

`ssl.keystore.path`::
Specifies the path to
the keystore that contains a private key and certificate.
Must be either a Java Keystore (jks) or a PKCS#12 file.
`ssl.key` and `ssl.keystore.path` cannot be used at the same time.

`ssl.keystore.type`::
The type of the keystore (`ssl.keystore.path`). Must be either `jks` or `PKCS12`.
If the keystore path ends in "".p12"", "".pfx"" or ""pkcs12"", this setting defaults 
to `PKCS12`. Otherwise, it defaults to `jks`.

`ssl.keystore.password`::
The password to the keystore (`ssl.keystore.path`). This setting cannot be used 
with `ssl.keystore.secure_password`.

`ssl.keystore.secure_password` (<<secure-settings,Secure>>)::
The password to the keystore (`ssl.keystore.path`).
This setting cannot be used with `ssl.keystore.password`.

`ssl.keystore.key_password`::
The password for the key in the keystore (`ssl.keystore.path`).
Defaults to the keystore password. This setting cannot be used with 
`ssl.keystore.secure_key_password`.

`ssl.keystore.secure_key_password` (<<secure-settings,Secure>>)::
The password for the key in the keystore (`ssl.keystore.path`).
Defaults to the keystore password. This setting cannot be used with 
`ssl.keystore.key_password`.

`ssl.truststore.path`::
The path to the
keystore that contains the certificates to trust.
Must be either a Java Keystore (jks) or a PKCS#12 file.
`ssl.certificate_authorities` and `ssl.truststore.path` cannot be used at the
same time.

`ssl.truststore.type`::
The type of the truststore (`ssl.truststore.path`). Must be either `jks` or 
`PKCS12`. If the keystore path ends in "".p12"", "".pfx"" or ""pkcs12"", this setting 
defaults to `PKCS12`. Otherwise, it defaults to `jks`.

`ssl.truststore.password`::
The password to the truststore (`ssl.truststore.path`). This setting cannot be 
used with `ssl.truststore.secure_password`.

`ssl.truststore.secure_password` (<<secure-settings,Secure>>)::
The password to the truststore (`ssl.truststore.path`). This setting cannot be 
used with `ssl.truststore.password`.

`ssl.verification_mode`::
One of `full`
(verify the hostname and the certificate path), `certificate` (verify the
certificate path, but not the hostname) or `none` (perform no verification).
Defaults to `full`.
+
See <<ssl-tls-settings,`xpack.ssl.verification_mode`>> for a more detailed
explanation of these values.

`ssl.supported_protocols`::
Specifies the supported protocols for TLS/SSL.

`ssl.cipher_suites`::
Specifies the
cipher suites that should be supported.

[float]
[[load-balancing]]
===== Load balancing and failover

The `load_balance.type` setting can have the following values: 

* `failover`: The URLs specified are used in the order that they are specified. 
The first server that can be connected to will be used for all subsequent 
connections. If a connection to that server fails then the next server that a 
connection can be established to will be used for subsequent connections.
* `dns_failover`: In this mode of operation, only a single URL may be specified.
This URL must contain a DNS name. The system will be queried for all IP 
addresses that correspond to this DNS name. Connections to the Active Directory 
or LDAP server will always be tried in the order in which they were retrieved. 
This differs from `failover` in that there is no reordering of the list and if a 
server has failed at the beginning of the list, it will still be tried for each 
subsequent connection.
* `round_robin`: Connections will continuously iterate through the list of 
provided URLs. If a server is unavailable, iterating through the list of URLs 
will continue until a successful connection is made.
* `dns_round_robin`: In this mode of operation, only a single URL may be 
specified. This URL must contain a DNS name. The system will be queried for all 
IP addresses that correspond to this DNS name. Connections will continuously 
iterate through the list of addresses. If a server is unavailable, iterating 
through the list of URLs will continue until a successful connection is made.

[float]
[[ssl-tls-settings]]
==== Default TLS/SSL settings
You can configure the following TLS/SSL settings in
`elasticsearch.yml`. For more information, see
{xpack-ref}/encrypting-communications.html[Encrypting communications]. These settings will be used
for all of {xpack} unless they have been overridden by more specific
settings such as those for HTTP or Transport.

`xpack.ssl.supported_protocols`::
Supported protocols with versions. Valid protocols: `SSLv2Hello`,
`SSLv3`, `TLSv1`, `TLSv1.1`, `TLSv1.2`. Defaults to `TLSv1.2`, `TLSv1.1`,
`TLSv1`.

`xpack.ssl.client_authentication`::
Controls the server's behavior in regard to requesting a certificate
from client connections. Valid values are `required`, `optional`, and `none`.
`required` forces a client to present a certificate, while `optional`
requests a client certificate but the client is not required to present one.
Defaults to `required`. This global setting is not applicable for HTTP, see
 <<http-tls-ssl-settings>>.

`xpack.ssl.verification_mode`::
Controls the verification of certificates. Valid values are:
- `full`, which verifies that the provided certificate is signed by a trusted
       authority (CA) and also verifies that the server's hostname (or IP
       address) matches the names identified within the certificate.
- `certificate`, which verifies that the provided certificate is signed by a
       trusted authority (CA), but does not perform any hostname verification.
- `none`, which performs _no verification_ of the server's certificate. This mode
       disables many of the security benefits of SSL/TLS and should only be
       used after very careful consideration. It is primarily intended as a
       temporary diagnostic mechanism when attempting to resolve TLS errors,
       and its use on production clusters is strongly discouraged.
+
The default value is `full`.

`xpack.ssl.cipher_suites`::
Supported cipher suites can be found in Oracle's http://docs.oracle.com/javase/8/docs/technotes/guides/security/SunProviders.html[
Java Cryptography Architecture documentation]. Defaults to `TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256`,
`TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256`, `TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA`, `TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA`,
`TLS_RSA_WITH_AES_128_CBC_SHA256`, `TLS_RSA_WITH_AES_128_CBC_SHA`. If the _Java Cryptography Extension (JCE) Unlimited Strength
Jurisdiction Policy Files_ has been installed, the default value also includes `TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384`,
`TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384`, `TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA`, `TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA`,
`TLS_RSA_WITH_AES_256_CBC_SHA256`, `TLS_RSA_WITH_AES_256_CBC_SHA`.

[float]
[[tls-ssl-key-settings]]
===== Default TLS/SSL key and trusted certificate settings

The following settings are used to specify a private key, certificate, and the
trusted certificates that should be used when communicating over an SSL/TLS connection.
If none of the settings below are specified, this will default to the <<ssl-tls-settings, {xpack}
defaults>>. If no trusted certificates are configured, the default certificates that are trusted by the JVM will be
trusted along with the certificate(s) from the <<tls-ssl-key-settings, key settings>>. The key and certificate must be in place
for connections that require client authentication or when acting as a SSL enabled server.

[float]
===== PEM encoded files

When using PEM encoded files, use the following settings:

`xpack.ssl.key`::
Path to the PEM encoded file containing the private key.

`xpack.ssl.key_passphrase`::
The passphrase that is used to decrypt the private key. This value is
optional as the key might not be encrypted.

`xpack.ssl.secure_key_passphrase` (<<secure-settings,Secure>>)::
The passphrase that is used to decrypt the private key. This value is
optional as the key might not be encrypted.

`xpack.ssl.certificate`::
Path to a PEM encoded file containing the certificate (or certificate chain)
that will be presented to clients when they connect.

`xpack.ssl.certificate_authorities`::
List of paths to the PEM encoded certificate files that should be trusted.

[float]
===== Java keystore files

When using Java keystore files (JKS), which contain the private key, certificate
and certificates that should be trusted, use the following settings:

`xpack.ssl.keystore.path`::
Path to the keystore that holds the private key and certificate.

`xpack.ssl.keystore.password`::
Password to the keystore.

`xpack.ssl.keystore.secure_password` (<<secure-settings,Secure>>)::
Password to the keystore.

`xpack.ssl.keystore.key_password`::
Password for the private key in the keystore. Defaults to the
same value as `xpack.ssl.keystore.password`.

`xpack.ssl.keystore.secure_key_password` (<<secure-settings,Secure>>)::
Password for the private key in the keystore.

`xpack.ssl.truststore.path`::
Path to the truststore file.

`xpack.ssl.truststore.password`::
Password to the truststore.

`xpack.ssl.truststore.secure_password` (<<secure-settings,Secure>>)::
Password to the truststore.

[float]
===== PKCS#12 files

When using PKCS#12 container files (`.p12` or `.pfx`), which contain the
private key, certificate, and certificates that should be trusted, use
the following settings:

`xpack.ssl.keystore.path`::
Path to the PKCS#12 file that holds the private key and certificate.

`xpack.ssl.keystore.type`::
Set this to `PKCS12`.

`xpack.ssl.keystore.password`::
Password to the PKCS#12 file.

`xpack.ssl.keystore.secure_password` (<<secure-settings,Secure>>)::
Password to the PKCS#12 file.

`xpack.ssl.keystore.key_password`::
Password for the private key in the PKCS12 file.
Defaults to the same value as `xpack.ssl.keystore.password`.

`xpack.ssl.keystore.secure_key_password` (<<secure-settings,Secure>>)::
Password for the private key in the PKCS12 file.

`xpack.ssl.truststore.path`::
Path to the truststore file.

`xpack.ssl.truststore.type`::
Set this to `PKCS12`.

`xpack.ssl.truststore.password`::
Password to the truststore.

`xpack.ssl.truststore.secure_password` (<<secure-settings,Secure>>)::
Password to the truststore.

[[http-tls-ssl-settings]]
:ssl-prefix:             xpack.security.http
:component:              HTTP
:client-auth-default:    none
:verifies!:
:server:

include::ssl-settings.asciidoc[]

[[transport-tls-ssl-settings]]
:ssl-prefix:             xpack.security.transport
:component:              Transport
:client-auth-default!:
:verifies:
:server:

include::ssl-settings.asciidoc[]

[[ssl-tls-profile-settings]]
[float]
===== Transport profile TLS/SSL settings
The same settings that are available for the <<transport-tls-ssl-settings, default transport>>
are also available for each transport profile. By default, the settings for a
transport profile will be the same as the default transport unless they
are specified.

As an example, lets look at the key setting. For the default transport
this is `xpack.security.transport.ssl.key`. In order to use this setting in a
transport profile, use the prefix `transport.profiles.$PROFILE.xpack.security.` and
append the portion of the setting after `xpack.security.transport.`. For the key
setting, this would be `transport.profiles.$PROFILE.xpack.security.ssl.key`.

[float]
[[ip-filtering-settings]]
==== IP filtering settings
You can configure the following settings for {xpack-ref}/ip-filtering.html[IP filtering].

`xpack.security.transport.filter.allow`::
List of IP addresses to allow.

`xpack.security.transport.filter.deny`::
List of IP addresses to deny.

`xpack.security.http.filter.allow`::
List of IP addresses to allow just for HTTP.

`xpack.security.http.filter.deny`::
List of IP addresses to deny just for HTTP.

`transport.profiles.$PROFILE.xpack.security.filter.allow`::
List of IP addresses to allow for this profile.

`transport.profiles.$PROFILE.xpack.security.filter.deny`::
List of IP addresses to deny for this profile.
",12350,False,2440.340551592327,median
"[[features.external-config]]
== Externalized Configuration
Spring Boot lets you externalize your configuration so that you can work with the same application code in different environments.
You can use a variety of external configuration sources, include Java properties files, YAML files, environment variables, and command-line arguments.

Property values can be injected directly into your beans by using the `@Value` annotation, accessed through Spring's `Environment` abstraction, or be <<features#features.external-config.typesafe-configuration-properties,bound to structured objects>> through `@ConfigurationProperties`.

Spring Boot uses a very particular `PropertySource` order that is designed to allow sensible overriding of values.
Properties are considered in the following order (with values from lower items overriding earlier ones):

. Default properties (specified by setting `SpringApplication.setDefaultProperties`).
. {spring-framework-api}/context/annotation/PropertySource.html[`@PropertySource`] annotations on your `@Configuration` classes.
  Please note that such property sources are not added to the `Environment` until the application context is being refreshed.
  This is too late to configure certain properties such as `+logging.*+` and `+spring.main.*+` which are read before refresh begins.
. Config data (such as `application.properties` files)
. A `RandomValuePropertySource` that has properties only in `+random.*+`.
. OS environment variables.
. Java System properties (`System.getProperties()`).
. JNDI attributes from `java:comp/env`.
. `ServletContext` init parameters.
. `ServletConfig` init parameters.
. Properties from `SPRING_APPLICATION_JSON` (inline JSON embedded in an environment variable or system property).
. Command line arguments.
. `properties` attribute on your tests.
  Available on {spring-boot-test-module-api}/context/SpringBootTest.html[`@SpringBootTest`] and the <<features#features.testing.spring-boot-applications.autoconfigured-tests,test annotations for testing a particular slice of your application>>.
. {spring-framework-api}/test/context/TestPropertySource.html[`@TestPropertySource`] annotations on your tests.
. <<using#using.devtools.globalsettings,Devtools global settings properties>> in the `$HOME/.config/spring-boot` directory when devtools is active.

Config data files are considered in the following order:

. <<features#features.external-config.files,Application properties>> packaged inside your jar (`application.properties` and YAML variants).
. <<features#features.external-config.files.profile-specific,Profile-specific application properties>> packaged inside your jar (`application-\\{profile}.properties` and YAML variants).
. <<features#features.external-config.files,Application properties>> outside of your packaged jar (`application.properties` and YAML variants).
. <<features#features.external-config.files.profile-specific,Profile-specific application properties>> outside of your packaged jar (`application-\\{profile}.properties` and YAML variants).

NOTE: It is recommended to stick with one format for your entire application.
If you have configuration files with both `.properties` and `.yml` format in the same location, `.properties` takes precedence.

To provide a concrete example, suppose you develop a `@Component` that uses a `name` property, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/MyBean.java[]
----

On your application classpath (for example, inside your jar) you can have an `application.properties` file that provides a sensible default property value for `name`.
When running in a new environment, an `application.properties` file can be provided outside of your jar that overrides the `name`.
For one-off testing, you can launch with a specific command line switch (for example, `java -jar app.jar --name=""Spring""`).

TIP: The `env` and `configprops` endpoints can be useful in determining why a property has a particular value.
You can use these two endpoints to diagnose unexpected property values.
See the ""<<actuator#actuator.endpoints, Production ready features>>"" section for details.



[[features.external-config.command-line-args]]
=== Accessing Command Line Properties
By default, `SpringApplication` converts any command line option arguments (that is, arguments starting with `--`, such as `--server.port=9000`) to a `property` and adds them to the Spring `Environment`.
As mentioned previously, command line properties always take precedence over file based property sources.

If you do not want command line properties to be added to the `Environment`, you can disable them by using `SpringApplication.setAddCommandLineProperties(false)`.



[[features.external-config.application-json]]
=== JSON Application Properties
Environment variables and system properties often have restrictions that mean some property names cannot be used.
To help with this, Spring Boot allows you to encode a block of properties into a single JSON structure.

When your application starts, any `spring.application.json` or `SPRING_APPLICATION_JSON` properties will be parsed and added to the `Environment`.

For example, the `SPRING_APPLICATION_JSON` property can be supplied on the command line in a UN{asterisk}X shell as an environment variable:

[source,shell,indent=0,subs=""verbatim""]
----
	$ SPRING_APPLICATION_JSON='{""my"":{""name"":""test""}}' java -jar myapp.jar
----

In the preceding example, you end up with `my.name=test` in the Spring `Environment`.

The same JSON can also be provided as a system property:

[source,shell,indent=0,subs=""verbatim""]
----
	$ java -Dspring.application.json='{""my"":{""name"":""test""}}' -jar myapp.jar
----

Or you could supply the JSON by using a command line argument:

[source,shell,indent=0,subs=""verbatim""]
----
	$ java -jar myapp.jar --spring.application.json='{""my"":{""name"":""test""}}'
----

If you are deploying to a classic Application Server, you could also use a JNDI variable named `java:comp/env/spring.application.json`.

NOTE: Although `null` values from the JSON will be added to the resulting property source, the `PropertySourcesPropertyResolver` treats `null` properties as missing values.
This means that the JSON cannot override properties from lower order property sources with a `null` value.



[[features.external-config.files]]
=== External Application Properties [[features.external-config.files]]
Spring Boot will automatically find and load `application.properties` and `application.yaml` files from the following locations when your application starts:

. The classpath root
. The classpath `/config` package
. The current directory
. The `/config` subdirectory in the current directory
. Immediate child directories of the `/config` subdirectory

The list is ordered by precedence (with values from lower items overriding earlier ones).
Documents from the loaded files are added as `PropertySources` to the Spring `Environment`.

If you do not like `application` as the configuration file name, you can switch to another file name by specifying a configprop:spring.config.name[] environment property.
You can also refer to an explicit location by using the `spring.config.location` environment property (which is a comma-separated list of directory locations or file paths).
The following example shows how to specify a different file name:

[source,shell,indent=0,subs=""verbatim""]
----
	$ java -jar myproject.jar --spring.config.name=myproject
----

The following example shows how to specify two locations:

[source,shell,indent=0,subs=""verbatim""]
----
	$ java -jar myproject.jar --spring.config.location=optional:classpath:/default.properties,optional:classpath:/override.properties
----

TIP: Use the prefix `optional:` if the <<features#features.external-config.files.optional-prefix,locations are optional>> and you don't mind if they don't exist.

WARNING: `spring.config.name`, `spring.config.location`, and `spring.config.additional-location` are used very early to determine which files have to be loaded.
They must be defined as an environment property (typically an OS environment variable, a system property, or a command-line argument).

If `spring.config.location` contains directories (as opposed to files), they must end in `/` or the system-dependent `File.separator`.
At runtime they will be appended with the names generated from `spring.config.name` before being loaded.
If `spring.config.location` contains files, they are used as-is.

Whether specified directly or contained in a directory, file references must include a file extension in their name.
Typical extensions that are supported out-of-the-box are `.properties`, `.yaml`, and `.yml`.

When multiple locations are specified, the later ones can override the values of earlier ones.

Locations configured by using `spring.config.location` replace the default locations.
For example, if `spring.config.location` is configured with the value `optional:classpath:/custom-config/,optional:file:./custom-config/`, the complete set of locations considered is:

. `optional:classpath:custom-config/`
. `optional:file:./custom-config/`

If you prefer to add additional locations, rather than replacing them, you can use `spring.config.additional-location`.
Properties loaded from additional locations can override those in the default locations.
For example, if `spring.config.additional-location` is configured with the value `optional:classpath:/custom-config/,optional:file:./custom-config/`, the complete set of locations considered is:

. `optional:classpath:/`
. `optional:classpath:/config/`
. `optional:file:./`
. `optional:file:./config/`
. `optional:file:./config/*/`
. `optional:classpath:custom-config/`
. `optional:file:./custom-config/`

This search ordering lets you specify default values in one configuration file and then selectively override those values in another.
You can provide default values for your application in `application.properties` (or whatever other basename you choose with `spring.config.name`) in one of the default locations.
These default values can then be overridden at runtime with a different file located in one of the custom locations.

NOTE: If you use environment variables rather than system properties, most operating systems disallow period-separated key names, but you can use underscores instead (for example, configprop:spring.config.name[format=envvar] instead of configprop:spring.config.name[]).
See <<features#features.external-config.typesafe-configuration-properties.relaxed-binding.environment-variables>> for details.

NOTE: If your application runs in a servlet container or application server, then JNDI properties (in `java:comp/env`) or servlet context initialization parameters can be used instead of, or as well as, environment variables or system properties.



[[features.external-config.files.optional-prefix]]
==== Optional Locations
By default, when a specified config data location does not exist, Spring Boot will throw a `ConfigDataLocationNotFoundException` and your application will not start.

If you want to specify a location, but you don't mind if it doesn't always exist, you can use the `optional:` prefix.
You can use this prefix with the `spring.config.location` and `spring.config.additional-location` properties, as well as with <<features#features.external-config.files.importing, `spring.config.import`>> declarations.

For example, a `spring.config.import` value of `optional:file:./myconfig.properties` allows your application to start, even if the `myconfig.properties` file is missing.

If you want to ignore all `ConfigDataLocationNotFoundExceptions` and always continue to start your application, you can use the `spring.config.on-not-found` property.
Set the value to `ignore` using `SpringApplication.setDefaultProperties(...)` or with a system/environment variable.



[[features.external-config.files.wildcard-locations]]
==== Wildcard Locations
If a config file location includes the `{asterisk}` character for the last path segment, it is considered a wildcard location.
Wildcards are expanded when the config is loaded so that immediate subdirectories are also checked.
Wildcard locations are particularly useful in an environment such as Kubernetes when there are multiple sources of config properties.

For example, if you have some Redis configuration and some MySQL configuration, you might want to keep those two pieces of configuration separate, while requiring that both those are present in an `application.properties` file.
This might result in two separate `application.properties` files mounted at different locations such as `/config/redis/application.properties` and `/config/mysql/application.properties`.
In such a case, having a wildcard location of `config/*/`, will result in both files being processed.

By default, Spring Boot includes `config/*/` in the default search locations.
It means that all subdirectories of the `/config` directory outside of your jar will be searched.

You can use wildcard locations yourself with the `spring.config.location` and `spring.config.additional-location` properties.

NOTE: A wildcard location must contain only one `{asterisk}` and end with `{asterisk}/` for search locations that are directories or `*/<filename>` for search locations that are files.
Locations with wildcards are sorted alphabetically based on the absolute path of the file names.

TIP: Wildcard locations only work with external directories.
You cannot use a wildcard in a `classpath:` location.



[[features.external-config.files.profile-specific]]
==== Profile Specific Files
As well as `application` property files, Spring Boot will also attempt to load profile-specific files using the naming convention `application-\\{profile}`.
For example, if your application activates a profile named `prod` and uses YAML files, then both `application.yml` and `application-prod.yml` will be considered.

Profile-specific properties are loaded from the same locations as standard `application.properties`, with profile-specific files always overriding the non-specific ones.
If several profiles are specified, a last-wins strategy applies.
For example, if profiles `prod,live` are specified by the configprop:spring.profiles.active[] property, values in `application-prod.properties` can be overridden by those in `application-live.properties`.

The `Environment` has a set of default profiles (by default, `[default]`) that are used if no active profiles are set.
In other words, if no profiles are explicitly activated, then properties from `application-default` are considered.

NOTE: Properties files are only ever loaded once.
If you've already directly <<features#features.external-config.files.importing,imported>> a profile specific property files then it won't be imported a second time.



[[features.external-config.files.importing]]
==== Importing Additional Data
Application properties may import further config data from other locations using the `spring.config.import` property.
Imports are processed as they are discovered, and are treated as additional documents inserted immediately below the one that declares the import.

For example, you might have the following in your classpath `application.properties` file:

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	spring:
	  application:
	    name: ""myapp""
	  config:
	    import: ""optional:file:./dev.properties""
----

This will trigger the import of a `dev.properties` file in current directory (if such a file exists).
Values from the imported `dev.properties` will take precedence over the file that triggered the import.
In the above example, the `dev.properties` could redefine `spring.application.name` to a different value.
An import will only be imported once no matter how many times it is declared.
The order an import is defined inside a single document within the properties/yaml file doesn't matter.
For instance, the two examples below produce the same result:

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	spring:
	  config:
	    import: my.properties
	my:
	  property: value
----

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	my:
	  property: value
	spring:
	  config:
	    import: my.properties
----

In both of the above examples, the values from the `my.properties` file will take precedence over the file that triggered its import.

Several locations can be specified under a single `spring.config.import` key.
Locations will be processed in the order that they are defined, with later imports taking precedence.

[TIP]
====
Spring Boot includes pluggable API that allows various different location addresses to be supported.
By default you can import Java Properties, YAML and ""`<<features#features.external-config.files.configtree, configuration trees>>`"".

Third-party jars can offer support for additional technologies (there's no requirement for files to be local).
For example, you can imagine config data being from external stores such as Consul, Apache ZooKeeper or Netflix Archaius.

If you want to support your own locations, see the `ConfigDataLocationResolver` and `ConfigDataLoader` classes in the `org.springframework.boot.context.config` package.
====



[[features.external-config.files.importing-extensionless]]
==== Importing Extensionless Files
Some cloud platforms cannot add a file extension to volume mounted files.
To import these extensionless files, you need to give Spring Boot a hint so that it knows how to load them.
You can do this by putting an extension hint in square brackets.

For example, suppose you have a `/etc/config/myconfig` file that you wish to import as yaml.
You can import it from your `application.properties` using the following:

[source,yaml,indent=0,subs=""verbatim"",configprops,configblocks]
----
	spring:
	  config:
	    import: ""file:/etc/config/myconfig[.yaml]""
----



[[features.external-config.files.configtree]]
==== Using Configuration Trees
When running applications on a cloud platform (such as Kubernetes) you often need to read config values that the platform supplies.
It's not uncommon to use environment variables for such purposes, but this can have drawbacks, especially if the value is supposed to be kept secret.

As an alternative to environment variables, many cloud platforms now allow you to map configuration into mounted data volumes.
For example, Kubernetes can volume mount both https://kubernetes.io/docs/tasks/configure-pod-container/configure-pod-configmap/#populate-a-volume-with-data-stored-in-a-configmap[`ConfigMaps`] and https://kubernetes.io/docs/concepts/configuration/secret/#using-secrets-as-files-from-a-pod[`Secrets`].

There are two common volume mount patterns that can be use:

. A single file contains a complete set of properties (usually written as YAML).
. Multiple files are written to a directory tree, with the filename becoming the '`key`' and the contents becoming the '`value`'.

For the first case, you can import the YAML or Properties file directly using `spring.config.import` as described <<features#features.external-config.files.importing,above>>.
For the second case, you need to use the `configtree:` prefix so that Spring Boot knows it needs to expose all the files as properties.

As an example, let's imagine that Kubernetes has mounted the following volume:

[indent=0]
----
	etc/
	  config/
	    myapp/
	      username
	      password
----

The contents of the `username` file would be a config value, and the contents of `password` would be a secret.

To import these properties, you can add the following to your `application.properties` or `application.yaml` file:

[source,yaml,indent=0,subs=""verbatim"",configprops,configblocks]
----
	spring:
	  config:
	    import: ""optional:configtree:/etc/config/""
----

You can then access or inject `myapp.username` and `myapp.password` properties from the `Environment` in the usual way.

TIP: Configuration tree values can be bound to both string `String` and `byte[]` types depending on the contents expected.

If you have multiple config trees to import from the same parent folder you can use a wildcard shortcut.
Any `configtree:` location that ends with `/*/` will import all immediate children as config trees.

For example, given the following volume:

[indent=0]
----
	etc/
	  config/
	    dbconfig/
	      db/
	        username
	        password
	    mqconfig/
	      mq/
	        username
	        password
----

You can use `configtree:/etc/config/*/` as the import location:

[source,yaml,indent=0,subs=""verbatim"",configprops,configblocks]
----
	spring:
	  config:
	    import: ""optional:configtree:/etc/config/*/""
----

This will add `db.username`, `db.password`, `mq.username` and `mq.password` properties.

NOTE: Directories loaded using a wildcard are sorted alphabetically.
If you need a different order, then you should list each location as a separate import


Configuration trees can also be used for Docker secrets.
When a Docker swarm service is granted access to a secret, the secret gets mounted into the container.
For example, if a secret named `db.password` is mounted at location `/run/secrets/`, you can make `db.password` available to the Spring environment using the following:

[source,yaml,indent=0,subs=""verbatim"",configprops,configblocks]
----
	spring:
	  config:
	    import: ""optional:configtree:/run/secrets/""
----



[[features.external-config.files.property-placeholders]]
==== Property Placeholders
The values in `application.properties` and `application.yml` are filtered through the existing `Environment` when they are used, so you can refer back to previously defined values (for example, from System properties).
The standard `$\\{name}` property-placeholder syntax can be used anywhere within a value.

For example, the following file will set `app.description` to ""`MyApp is a Spring Boot application`"":

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	app:
	  name: ""MyApp""
	  description: ""${app.name} is a Spring Boot application""
----

TIP: You can also use this technique to create ""`short`"" variants of existing Spring Boot properties.
See the _<<howto#howto.properties-and-configuration.short-command-line-arguments>>_ how-to for details.



[[features.external-config.files.multi-document]]
==== Working with Multi-Document Files
Spring Boot allows you to split a single physical file into multiple logical documents which are each added independently.
Documents are processed in order, from top to bottom.
Later documents can override the properties defined in earlier ones.

For `application.yml` files, the standard YAML multi-document syntax is used.
Three consecutive hyphens represent the end of one document, and the start of the next.

For example, the following file has two logical documents:

[source,yaml,indent=0,subs=""verbatim""]
----
	spring.application.name: MyApp
	---
	spring.config.activate.on-cloud-platform: kubernetes
	spring.application.name: MyCloudApp
----

For `application.properties` files a special `#---` comment is used to mark the document splits:

[source,properties,indent=0,subs=""verbatim""]
----
	spring.application.name=MyApp
	#---
	spring.config.activate.on-cloud-platform=kubernetes
	spring.application.name=MyCloudApp
----

NOTE: Property file separators must not have any leading whitespace and must have exactly three hyphen characters.
The lines immediately before and after the separator must not be comments.

TIP: Multi-document property files are often used in conjunction with activation properties such as `spring.config.activate.on-profile`.
See the <<features#features.external-config.files.activation-properties, next section>> for details.

WARNING: Multi-document property files cannot be loaded by using the `@PropertySource` or `@TestPropertySource` annotations.



[[features.external-config.files.activation-properties]]
==== Activation Properties
It's sometimes useful to only activate a given get of properties when certain conditions are met.
For example, you might have properties that are only relevant when a specific profile is active.

You can conditionally activate a properties document using `spring.config.activate.*`.

The following activation properties are available:

.activation properties
[cols=""1,4""]
|===
| Property | Note

| `on-profile`
| A profile expression that must match for the document to be active.

| `on-cloud-platform`
| The `CloudPlatform` that must be detected for the document to be active.
|===

For example, the following specifies that the second document is only active when running on Kubernetes, and only when either the ""`prod`"" or ""`staging`"" profiles are active:

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	myprop:
	  always-set
	---
	spring:
	  config:
	    activate:
	      on-cloud-platform: ""kubernetes""
	      on-profile: ""prod | staging""
	myotherprop: sometimes-set
----



[[features.external-config.encrypting]]
=== Encrypting Properties
Spring Boot does not provide any built in support for encrypting property values, however, it does provide the hook points necessary to modify values contained in the Spring `Environment`.
The `EnvironmentPostProcessor` interface allows you to manipulate the `Environment` before the application starts.
See <<howto#howto.application.customize-the-environment-or-application-context>> for details.

If you're looking for a secure way to store credentials and passwords, the https://cloud.spring.io/spring-cloud-vault/[Spring Cloud Vault] project provides support for storing externalized configuration in https://www.vaultproject.io/[HashiCorp Vault].



[[features.external-config.yaml]]
=== Working with YAML
https://yaml.org[YAML] is a superset of JSON and, as such, is a convenient format for specifying hierarchical configuration data.
The `SpringApplication` class automatically supports YAML as an alternative to properties whenever you have the https://bitbucket.org/asomov/snakeyaml[SnakeYAML] library on your classpath.

NOTE: If you use ""`Starters`"", SnakeYAML is automatically provided by `spring-boot-starter`.



[[features.external-config.yaml.mapping-to-properties]]
==== Mapping YAML to Properties
YAML documents need to be converted from their hierarchical format to a flat structure that can be used with the Spring `Environment`.
For example, consider the following YAML document:

[source,yaml,indent=0,subs=""verbatim""]
----
	environments:
	  dev:
	    url: https://dev.example.com
	    name: Developer Setup
	  prod:
	    url: https://another.example.com
	    name: My Cool App
----

In order to access these properties from the `Environment`, they would be flattened as follows:

[source,properties,indent=0,subs=""verbatim""]
----
	environments.dev.url=https://dev.example.com
	environments.dev.name=Developer Setup
	environments.prod.url=https://another.example.com
	environments.prod.name=My Cool App
----

Likewise, YAML lists also need to be flattened.
They are represented as property keys with `[index]` dereferencers.
For example, consider the following YAML:

[source,yaml,indent=0,subs=""verbatim""]
----
	 my:
	  servers:
	  - dev.example.com
	  - another.example.com
----

The preceding example would be transformed into these properties:

[source,properties,indent=0,subs=""verbatim""]
----
	my.servers[0]=dev.example.com
	my.servers[1]=another.example.com
----

TIP: Properties that use the `[index]` notation can be bound to Java `List` or `Set` objects using Spring Boot's `Binder` class.
For more details see the ""`<<features#features.external-config.typesafe-configuration-properties>>`"" section below.

WARNING: YAML files cannot be loaded by using the `@PropertySource` or `@TestPropertySource` annotations.
So, in the case that you need to load values that way, you need to use a properties file.



[[features.external-config.yaml.directly-loading]]
[[features.external-config.yaml.directly-loading]]
==== Directly Loading YAML
Spring Framework provides two convenient classes that can be used to load YAML documents.
The `YamlPropertiesFactoryBean` loads YAML as `Properties` and the `YamlMapFactoryBean` loads YAML as a `Map`.

You can also use the `YamlPropertySourceLoader` class if you want to load YAML as a Spring `PropertySource`.



[[features.external-config.random-values]]
=== Configuring Random Values
The `RandomValuePropertySource` is useful for injecting random values (for example, into secrets or test cases).
It can produce integers, longs, uuids, or strings, as shown in the following example:

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	my:
	  secret: ""${random.value}""
	  number: ""${random.int}""
	  bignumber: ""${random.long}""
	  uuid: ""${random.uuid}""
	  number-less-than-ten: ""${random.int(10)}""
	  number-in-range: ""${random.int[1024,65536]}""
----

The `+random.int*+` syntax is `OPEN value (,max) CLOSE` where the `OPEN,CLOSE` are any character and `value,max` are integers.
If `max` is provided, then `value` is the minimum value and `max` is the maximum value (exclusive).



[[features.external-config.system-environment]]
=== Configuring System Environment Properties
Spring Boot supports setting a prefix for environment properties.
This is useful if the system environment is shared by multiple Spring Boot applications with different configuration requirements.
The prefix for system environment properties can be set directly on `SpringApplication`.

For example, if you set the prefix to `input`, a property such as `remote.timeout` will also be resolved as `input.remote.timeout` in the system environment.



[[features.external-config.typesafe-configuration-properties]]
=== Type-safe Configuration Properties
Using the `@Value(""$\\{property}"")` annotation to inject configuration properties can sometimes be cumbersome, especially if you are working with multiple properties or your data is hierarchical in nature.
Spring Boot provides an alternative method of working with properties that lets strongly typed beans govern and validate the configuration of your application.

TIP: See also the <<features#features.external-config.typesafe-configuration-properties.vs-value-annotation,differences between `@Value` and type-safe configuration properties>>.



[[features.external-config.typesafe-configuration-properties.java-bean-binding]]
==== JavaBean properties binding
It is possible to bind a bean declaring standard JavaBean properties as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/javabeanbinding/MyProperties.java[]
----

The preceding POJO defines the following properties:

* `my.service.enabled`, with a value of `false` by default.
* `my.service.remote-address`, with a type that can be coerced from `String`.
* `my.service.security.username`, with a nested ""security"" object whose name is determined by the name of the property.
  In particular, the return type is not used at all there and could have been `SecurityProperties`.
* `my.service.security.password`.
* `my.service.security.roles`, with a collection of `String` that defaults to `USER`.

NOTE: The properties that map to `@ConfigurationProperties` classes available in Spring Boot, which are configured via properties files, YAML files, environment variables etc., are public API but the accessors (getters/setters) of the class itself are not meant to be used directly.

[NOTE]
====
Such arrangement relies on a default empty constructor and getters and setters are usually mandatory, since binding is through standard Java Beans property descriptors, just like in Spring MVC.
A setter may be omitted in the following cases:

* Maps, as long as they are initialized, need a getter but not necessarily a setter, since they can be mutated by the binder.
* Collections and arrays can be accessed either through an index (typically with YAML) or by using a single comma-separated value (properties).
  In the latter case, a setter is mandatory.
  We recommend to always add a setter for such types.
  If you initialize a collection, make sure it is not immutable (as in the preceding example).
* If nested POJO properties are initialized (like the `Security` field in the preceding example), a setter is not required.
  If you want the binder to create the instance on the fly by using its default constructor, you need a setter.

Some people use Project Lombok to add getters and setters automatically.
Make sure that Lombok does not generate any particular constructor for such a type, as it is used automatically by the container to instantiate the object.

Finally, only standard Java Bean properties are considered and binding on static properties is not supported.
====



[[features.external-config.typesafe-configuration-properties.constructor-binding]]
==== Constructor binding
The example in the previous section can be rewritten in an immutable fashion as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/constructorbinding/MyProperties.java[]
----

In this setup, the `@ConstructorBinding` annotation is used to indicate that constructor binding should be used.
This means that the binder will expect to find a constructor with the parameters that you wish to have bound.

Nested members of a `@ConstructorBinding` class (such as `Security` in the example above) will also be bound via their constructor.

Default values can be specified using `@DefaultValue` and the same conversion service will be applied to coerce the `String` value to the target type of a missing property.
By default, if no properties are bound to `Security`, the `MyProperties` instance will contain a `null` value for `security`.
If you wish you return a non-null instance of `Security` even when no properties are bound to it, you can use an empty `@DefaultValue` annotation to do so:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/constructorbinding/nonnull/MyProperties.java[]
----


NOTE: To use constructor binding the class must be enabled using `@EnableConfigurationProperties` or configuration property scanning.
You cannot use constructor binding with beans that are created by the regular Spring mechanisms (e.g. `@Component` beans, beans created via `@Bean` methods or beans loaded using `@Import`)

TIP: If you have more than one constructor for your class you can also use `@ConstructorBinding` directly on the constructor that should be bound.

NOTE: The use of `java.util.Optional` with `@ConfigurationProperties` is not recommended as it is primarily intended for use as a return type.
As such, it is not well-suited to configuration property injection.
For consistency with properties of other types, if you do declare an `Optional` property and it has no value, `null` rather than an empty `Optional` will be bound.



[[features.external-config.typesafe-configuration-properties.enabling-annotated-types]]
==== Enabling @ConfigurationProperties-annotated types
Spring Boot provides infrastructure to bind `@ConfigurationProperties` types and register them as beans.
You can either enable configuration properties on a class-by-class basis or enable configuration property scanning that works in a similar manner to component scanning.

Sometimes, classes annotated with `@ConfigurationProperties` might not be suitable for scanning, for example, if you're developing your own auto-configuration or you want to enable them conditionally.
In these cases, specify the list of types to process using the `@EnableConfigurationProperties` annotation.
This can be done on any `@Configuration` class, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/enablingannotatedtypes/MyConfiguration.java[]
----

To use configuration property scanning, add the `@ConfigurationPropertiesScan` annotation to your application.
Typically, it is added to the main application class that is annotated with `@SpringBootApplication` but it can be added to any `@Configuration` class.
By default, scanning will occur from the package of the class that declares the annotation.
If you want to define specific packages to scan, you can do so as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/enablingannotatedtypes/MyApplication.java[]
----

[NOTE]
====
When the `@ConfigurationProperties` bean is registered using configuration property scanning or via `@EnableConfigurationProperties`, the bean has a conventional name: `<prefix>-<fqn>`, where `<prefix>` is the environment key prefix specified in the `@ConfigurationProperties` annotation and `<fqn>` is the fully qualified name of the bean.
If the annotation does not provide any prefix, only the fully qualified name of the bean is used.

The bean name in the example above is `com.example.app-com.example.app.SomeProperties`.
====

We recommend that `@ConfigurationProperties` only deal with the environment and, in particular, does not inject other beans from the context.
For corner cases, setter injection can be used or any of the `*Aware` interfaces provided by the framework (such as `EnvironmentAware` if you need access to the `Environment`).
If you still want to inject other beans using the constructor, the configuration properties bean must be annotated with `@Component` and use JavaBean-based property binding.



[[features.external-config.typesafe-configuration-properties.using-annotated-types]]
==== Using @ConfigurationProperties-annotated types
This style of configuration works particularly well with the `SpringApplication` external YAML configuration, as shown in the following example:

[source,yaml,indent=0,subs=""verbatim""]
----
	my:
		service:
			remote-address: 192.168.1.1
			security:
				username: admin
				roles:
				  - USER
				  - ADMIN
----

To work with `@ConfigurationProperties` beans, you can inject them in the same way as any other bean, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/usingannotatedtypes/MyService.java[]
----

TIP: Using `@ConfigurationProperties` also lets you generate metadata files that can be used by IDEs to offer auto-completion for your own keys.
See the <<configuration-metadata#configuration-metadata,appendix>> for details.



[[features.external-config.typesafe-configuration-properties.third-party-configuration]]
==== Third-party Configuration
As well as using `@ConfigurationProperties` to annotate a class, you can also use it on public `@Bean` methods.
Doing so can be particularly useful when you want to bind properties to third-party components that are outside of your control.

To configure a bean from the `Environment` properties, add `@ConfigurationProperties` to its bean registration, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/thirdpartyconfiguration/ThirdPartyConfiguration.java[]
----

Any JavaBean property defined with the `another` prefix is mapped onto that `AnotherComponent` bean in manner similar to the preceding `SomeProperties` example.



[[features.external-config.typesafe-configuration-properties.relaxed-binding]]
==== Relaxed Binding
Spring Boot uses some relaxed rules for binding `Environment` properties to `@ConfigurationProperties` beans, so there does not need to be an exact match between the `Environment` property name and the bean property name.
Common examples where this is useful include dash-separated environment properties (for example, `context-path` binds to `contextPath`), and capitalized environment properties (for example, `PORT` binds to `port`).

As an example, consider the following `@ConfigurationProperties` class:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/relaxedbinding/MyPersonProperties.java[]
----

With the preceding code, the following properties names can all be used:

.relaxed binding
[cols=""1,4""]
|===
| Property | Note

| `my.main-project.person.first-name`
| Kebab case, which is recommended for use in `.properties` and `.yml` files.

| `my.main-project.person.firstName`
| Standard camel case syntax.

| `my.main-project.person.first_name`
| Underscore notation, which is an alternative format for use in `.properties` and `.yml` files.

| `MY_MAINPROJECT_PERSON_FIRSTNAME`
| Upper case format, which is recommended when using system environment variables.
|===

NOTE: The `prefix` value for the annotation _must_ be in kebab case (lowercase and separated by `-`, such as `my.main-project.person`).

.relaxed binding rules per property source
[cols=""2,4,4""]
|===
| Property Source | Simple | List

| Properties Files
| Camel case, kebab case, or underscore notation
| Standard list syntax using `[ ]` or comma-separated values

| YAML Files
| Camel case, kebab case, or underscore notation
| Standard YAML list syntax or comma-separated values

| Environment Variables
| Upper case format with underscore as the delimiter (see <<features#features.external-config.typesafe-configuration-properties.relaxed-binding.environment-variables>>).
| Numeric values surrounded by underscores (see <<features#features.external-config.typesafe-configuration-properties.relaxed-binding.environment-variables>>)

| System properties
| Camel case, kebab case, or underscore notation
| Standard list syntax using `[ ]` or comma-separated values
|===

TIP: We recommend that, when possible, properties are stored in lower-case kebab format, such as `my.person.first-name=Rod`.



[[features.external-config.typesafe-configuration-properties.relaxed-binding.maps]]
===== Binding Maps
When binding to `Map` properties you may need to use a special bracket notation so that the original `key` value is preserved.
If the key is not surrounded by `[]`, any characters that are not alpha-numeric, `-` or `.` are removed.

For example, consider binding the following properties to a `Map<String,String>`:


[source,properties,indent=0,subs=""verbatim"",role=""primary""]
.Properties
----
	my.map.[/key1]=value1
	my.map.[/key2]=value2
	my.map./key3=value3
----

[source,yaml,indent=0,subs=""verbatim"",role=""secondary""]
.Yaml
----
	my:
	  map:
	    ""[/key1]"": ""value1""
	    ""[/key2]"": ""value2""
	    ""/key3"": ""value3""
----

NOTE: For YAML files, the brackets need to be surrounded by quotes for the keys to be parsed properly.

The properties above will bind to a `Map` with `/key1`, `/key2` and `key3` as the keys in the map.
The slash has been removed from `key3` because it wasn't surrounded by square brackets.

You may also occasionally need to use the bracket notation if your `key` contains a `.` and you are binding to non-scalar value.
For example, binding `a.b=c` to `Map<String, Object>` will return a Map with the entry `{""a""={""b""=""c""}}` whereas `[a.b]=c` will return a Map with the entry `{""a.b""=""c""}`.



[[features.external-config.typesafe-configuration-properties.relaxed-binding.environment-variables]]
===== Binding from Environment Variables
Most operating systems impose strict rules around the names that can be used for environment variables.
For example, Linux shell variables can contain only letters (`a` to `z` or `A` to `Z`), numbers (`0` to `9`) or the underscore character (`_`).
By convention, Unix shell variables will also have their names in UPPERCASE.

Spring Boot's relaxed binding rules are, as much as possible, designed to be compatible with these naming restrictions.

To convert a property name in the canonical-form to an environment variable name you can follow these rules:

* Replace dots (`.`) with underscores (`_`).
* Remove any dashes (`-`).
* Convert to uppercase.

For example, the configuration property `spring.main.log-startup-info` would be an environment variable named `SPRING_MAIN_LOGSTARTUPINFO`.

Environment variables can also be used when binding to object lists.
To bind to a `List`, the element number should be surrounded with underscores in the variable name.

For example, the configuration property `my.service[0].other` would use an environment variable named `MY_SERVICE_0_OTHER`.



[[features.external-config.typesafe-configuration-properties.merging-complex-types]]
==== Merging Complex Types
When lists are configured in more than one place, overriding works by replacing the entire list.

For example, assume a `MyPojo` object with `name` and `description` attributes that are `null` by default.
The following example exposes a list of `MyPojo` objects from `MyProperties`:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/mergingcomplextypes/list/MyProperties.java[]
----

Consider the following configuration:

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	my:
	  list:
	  - name: ""my name""
	    description: ""my description""
	---
	spring:
	  config:
	    activate:
	      on-profile: ""dev""
	my:
	  list:
	  - name: ""my another name""
----

If the `dev` profile is not active, `MyProperties.list` contains one `MyPojo` entry, as previously defined.
If the `dev` profile is enabled, however, the `list` _still_ contains only one entry (with a name of `my another name` and a description of `null`).
This configuration _does not_ add a second `MyPojo` instance to the list, and it does not merge the items.

When a `List` is specified in multiple profiles, the one with the highest priority (and only that one) is used.
Consider the following example:

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	my:
	  list:
	  - name: ""my name""
	    description: ""my description""
	  - name: ""another name""
	    description: ""another description""
	---
	spring:
	  config:
	    activate:
	      on-profile: ""dev""
	my:
	  list:
	  - name: ""my another name""
----

In the preceding example, if the `dev` profile is active, `MyProperties.list` contains _one_ `MyPojo` entry (with a name of `my another name` and a description of `null`).
For YAML, both comma-separated lists and YAML lists can be used for completely overriding the contents of the list.

For `Map` properties, you can bind with property values drawn from multiple sources.
However, for the same property in multiple sources, the one with the highest priority is used.
The following example exposes a `Map<String, MyPojo>` from `MyProperties`:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/mergingcomplextypes/map/MyProperties.java[]
----

Consider the following configuration:

[source,yaml,indent=0,subs=""verbatim"",configblocks]
----
	my:
	  map:
	    key1:
	      name: ""my name 1""
	      description: ""my description 1""
	---
	spring:
	  config:
	    activate:
	      on-profile: ""dev""
	my:
	  map:
	    key1:
	      name: ""dev name 1""
	    key2:
	      name: ""dev name 2""
	      description: ""dev description 2""
----

If the `dev` profile is not active, `MyProperties.map` contains one entry with key `key1` (with a name of `my name 1` and a description of `my description 1`).
If the `dev` profile is enabled, however, `map` contains two entries with keys `key1` (with a name of `dev name 1` and a description of `my description 1`) and `key2` (with a name of `dev name 2` and a description of `dev description 2`).

NOTE: The preceding merging rules apply to properties from all property sources, and not just files.



[[features.external-config.typesafe-configuration-properties.conversion]]
==== Properties Conversion
Spring Boot attempts to coerce the external application properties to the right type when it binds to the `@ConfigurationProperties` beans.
If you need custom type conversion, you can provide a `ConversionService` bean (with a bean named `conversionService`) or custom property editors (through a `CustomEditorConfigurer` bean) or custom `Converters` (with bean definitions annotated as `@ConfigurationPropertiesBinding`).

NOTE: As this bean is requested very early during the application lifecycle, make sure to limit the dependencies that your `ConversionService` is using.
Typically, any dependency that you require may not be fully initialized at creation time.
You may want to rename your custom `ConversionService` if it is not required for configuration keys coercion and only rely on custom converters qualified with `@ConfigurationPropertiesBinding`.



[[features.external-config.typesafe-configuration-properties.conversion.durations]]
===== Converting Durations
Spring Boot has dedicated support for expressing durations.
If you expose a `java.time.Duration` property, the following formats in application properties are available:

* A regular `long` representation (using milliseconds as the default unit unless a `@DurationUnit` has been specified)
* The standard ISO-8601 format {java-api}/java/time/Duration.html#parse-java.lang.CharSequence-[used by `java.time.Duration`]
* A more readable format where the value and the unit are coupled (e.g. `10s` means 10 seconds)

Consider the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/conversion/durations/javabeanbinding/MyProperties.java[]
----

To specify a session timeout of 30 seconds, `30`, `PT30S` and `30s` are all equivalent.
A read timeout of 500ms can be specified in any of the following form: `500`, `PT0.5S` and `500ms`.

You can also use any of the supported units.
These are:

* `ns` for nanoseconds
* `us` for microseconds
* `ms` for milliseconds
* `s` for seconds
* `m` for minutes
* `h` for hours
* `d` for days

The default unit is milliseconds and can be overridden using `@DurationUnit` as illustrated in the sample above.

If you prefer to use constructor binding, the same properties can be exposed, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/conversion/durations/constructorbinding/MyProperties.java[]
----


TIP: If you are upgrading a `Long` property, make sure to define the unit (using `@DurationUnit`) if it isn't milliseconds.
Doing so gives a transparent upgrade path while supporting a much richer format.



[[features.external-config.typesafe-configuration-properties.conversion.periods]]
===== Converting periods
In addition to durations, Spring Boot can also work with `java.time.Period` type.
The following formats can be used in application properties:

* An regular `int` representation (using days as the default unit unless a `@PeriodUnit` has been specified)
* The standard ISO-8601 format {java-api}/java/time/Period.html#parse-java.lang.CharSequence-[used by `java.time.Period`]
* A simpler format where the value and the unit pairs are coupled (e.g. `1y3d` means 1 year and 3 days)

The following units are supported with the simple format:

* `y` for years
* `m` for months
* `w` for weeks
* `d` for days

NOTE: The `java.time.Period` type never actually stores the number of weeks, it is a shortcut that means ""`7 days`"".



[[features.external-config.typesafe-configuration-properties.conversion.data-sizes]]
===== Converting Data Sizes
Spring Framework has a `DataSize` value type that expresses a size in bytes.
If you expose a `DataSize` property, the following formats in application properties are available:

* A regular `long` representation (using bytes as the default unit unless a `@DataSizeUnit` has been specified)
* A more readable format where the value and the unit are coupled (e.g. `10MB` means 10 megabytes)

Consider the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/conversion/datasizes/javabeanbinding/MyProperties.java[]
----

To specify a buffer size of 10 megabytes, `10` and `10MB` are equivalent.
A size threshold of 256 bytes can be specified as `256` or `256B`.

You can also use any of the supported units.
These are:

* `B` for bytes
* `KB` for kilobytes
* `MB` for megabytes
* `GB` for gigabytes
* `TB` for terabytes

The default unit is bytes and can be overridden using `@DataSizeUnit` as illustrated in the sample above.

If you prefer to use constructor binding, the same properties can be exposed, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/conversion/datasizes/constructorbinding/MyProperties.java[]
----

TIP: If you are upgrading a `Long` property, make sure to define the unit (using `@DataSizeUnit`) if it isn't bytes.
Doing so gives a transparent upgrade path while supporting a much richer format.



[[features.external-config.typesafe-configuration-properties.validation]]
==== @ConfigurationProperties Validation
Spring Boot attempts to validate `@ConfigurationProperties` classes whenever they are annotated with Spring's `@Validated` annotation.
You can use JSR-303 `javax.validation` constraint annotations directly on your configuration class.
To do so, ensure that a compliant JSR-303 implementation is on your classpath and then add constraint annotations to your fields, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/validate/MyProperties.java[]
----

TIP: You can also trigger validation by annotating the `@Bean` method that creates the configuration properties with `@Validated`.

To ensure that validation is always triggered for nested properties, even when no properties are found, the associated field must be annotated with `@Valid`.
The following example builds on the preceding `MyProperties` example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/externalconfig/typesafeconfigurationproperties/validate/nested/MyProperties.java[]
----

You can also add a custom Spring `Validator` by creating a bean definition called `configurationPropertiesValidator`.
The `@Bean` method should be declared `static`.
The configuration properties validator is created very early in the application's lifecycle, and declaring the `@Bean` method as static lets the bean be created without having to instantiate the `@Configuration` class.
Doing so avoids any problems that may be caused by early instantiation.

TIP: The `spring-boot-actuator` module includes an endpoint that exposes all `@ConfigurationProperties` beans.
Point your web browser to `/actuator/configprops` or use the equivalent JMX endpoint.
See the ""<<actuator#actuator.endpoints, Production ready features>>"" section for details.



[[features.external-config.typesafe-configuration-properties.vs-value-annotation]]
==== @ConfigurationProperties vs. @Value
The `@Value` annotation is a core container feature, and it does not provide the same features as type-safe configuration properties.
The following table summarizes the features that are supported by `@ConfigurationProperties` and `@Value`:

[cols=""4,2,2""]
|===
| Feature |`@ConfigurationProperties` |`@Value`

| <<features#features.external-config.typesafe-configuration-properties.relaxed-binding,Relaxed binding>>
| Yes
| Limited (see <<features#features.external-config.typesafe-configuration-properties.vs-value-annotation.note,note below>>)

| <<configuration-metadata#configuration-metadata,Meta-data support>>
| Yes
| No

| `SpEL` evaluation
| No
| Yes
|===

[[features.external-config.typesafe-configuration-properties.vs-value-annotation.note]]
NOTE: If you do want to use `@Value`, we recommend that you refer to property names using their canonical form (kebab-case using only lowercase letters).
This will allow Spring Boot to use the same logic as it does when relaxed binding `@ConfigurationProperties`.
For example, `@Value(""{demo.item-price}"")` will pick up `demo.item-price` and `demo.itemPrice` forms from the `application.properties` file, as well as `DEMO_ITEMPRICE` from the system environment.
If you used `@Value(""{demo.itemPrice}"")` instead, `demo.item-price` and `DEMO_ITEMPRICE` would not be considered.

If you define a set of configuration keys for your own components, we recommend you group them in a POJO annotated with `@ConfigurationProperties`.
Doing so will provide you with structured, type-safe object that you can inject into your own beans.

`SpEL` expressions from  <<features#features.external-config.files,application property files>> are not processed at time of parsing these files and populating the environment.
However, it is possible to write a `SpEL` expression in `@Value`.
If the value of a property from an application property file is a `SpEL` expression, it will be evaluated when consumed via `@Value`.
",12120,False,2204.175274586871,median
"CLASS zcl_abapgit_objects DEFINITION
  PUBLIC
  CREATE PUBLIC .

  PUBLIC SECTION.

    TYPES:
      ty_types_tt TYPE STANDARD TABLE OF tadir-object WITH DEFAULT KEY .
    TYPES:
      BEGIN OF ty_deserialization,
        obj     TYPE REF TO zif_abapgit_object,
        xml     TYPE REF TO zcl_abapgit_xml_input,
        package TYPE devclass,
        item    TYPE zif_abapgit_definitions=>ty_item,
      END OF ty_deserialization .
    TYPES:
      ty_deserialization_tt TYPE STANDARD TABLE OF ty_deserialization WITH DEFAULT KEY .
    TYPES:
      BEGIN OF ty_serialization,
        files TYPE zif_abapgit_definitions=>ty_files_tt,
        item  TYPE zif_abapgit_definitions=>ty_item,
      END OF ty_serialization .

    CLASS-METHODS serialize
      IMPORTING
        !is_item                 TYPE zif_abapgit_definitions=>ty_item
        !iv_language             TYPE spras
      RETURNING
        VALUE(rs_files_and_item) TYPE zcl_abapgit_objects=>ty_serialization
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS deserialize
      IMPORTING
        !io_repo                 TYPE REF TO zcl_abapgit_repo
        !is_checks               TYPE zif_abapgit_definitions=>ty_deserialize_checks
      RETURNING
        VALUE(rt_accessed_files) TYPE zif_abapgit_definitions=>ty_file_signatures_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS deserialize_checks
      IMPORTING
        !io_repo         TYPE REF TO zcl_abapgit_repo
      RETURNING
        VALUE(rs_checks) TYPE zif_abapgit_definitions=>ty_deserialize_checks
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS delete
      IMPORTING
        !it_tadir  TYPE zif_abapgit_definitions=>ty_tadir_tt
        !is_checks TYPE zif_abapgit_definitions=>ty_delete_checks OPTIONAL
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS jump
      IMPORTING
        !is_item        TYPE zif_abapgit_definitions=>ty_item
        !iv_line_number TYPE i OPTIONAL
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS changed_by
      IMPORTING
        !is_item       TYPE zif_abapgit_definitions=>ty_item
      RETURNING
        VALUE(rv_user) TYPE xubname
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS has_changed_since
      IMPORTING
        !is_item          TYPE zif_abapgit_definitions=>ty_item
        !iv_timestamp     TYPE timestamp
      RETURNING
        VALUE(rv_changed) TYPE abap_bool
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS is_supported
      IMPORTING
        !is_item        TYPE zif_abapgit_definitions=>ty_item
        !iv_native_only TYPE abap_bool DEFAULT abap_false
      RETURNING
        VALUE(rv_bool)  TYPE abap_bool .
    CLASS-METHODS exists
      IMPORTING
        !is_item       TYPE zif_abapgit_definitions=>ty_item
      RETURNING
        VALUE(rv_bool) TYPE abap_bool .
    CLASS-METHODS supported_list
      RETURNING
        VALUE(rt_types) TYPE ty_types_tt .
    CLASS-METHODS is_active
      IMPORTING
        !is_item         TYPE zif_abapgit_definitions=>ty_item
      RETURNING
        VALUE(rv_active) TYPE abap_bool
      RAISING
        zcx_abapgit_exception .
  PROTECTED SECTION.

  PRIVATE SECTION.
    TYPES: BEGIN OF ty_obj_serializer_map,
             item     TYPE zif_abapgit_definitions=>ty_item,
             metadata TYPE zif_abapgit_definitions=>ty_metadata,
           END OF ty_obj_serializer_map,
           tty_obj_serializer_map
        TYPE SORTED TABLE OF ty_obj_serializer_map WITH UNIQUE KEY item.
    CLASS-DATA gt_obj_serializer_map TYPE tty_obj_serializer_map.

    CLASS-METHODS files_to_deserialize
      IMPORTING
        !io_repo          TYPE REF TO zcl_abapgit_repo
      RETURNING
        VALUE(rt_results) TYPE zif_abapgit_definitions=>ty_results_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS check_duplicates
      IMPORTING
        !it_files TYPE zif_abapgit_definitions=>ty_files_tt
      RAISING
        zcx_abapgit_exception .

    CLASS-METHODS prioritize_deser
      IMPORTING
        !it_results       TYPE zif_abapgit_definitions=>ty_results_tt
      RETURNING
        VALUE(rt_results) TYPE zif_abapgit_definitions=>ty_results_tt .
    CLASS-METHODS class_name
      IMPORTING
        !is_item             TYPE zif_abapgit_definitions=>ty_item
      RETURNING
        VALUE(rv_class_name) TYPE string .
    CLASS-METHODS warning_overwrite_adjust
      IMPORTING
        !it_overwrite TYPE zif_abapgit_definitions=>ty_overwrite_tt
      CHANGING
        !ct_results   TYPE zif_abapgit_definitions=>ty_results_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS checks_adjust
      IMPORTING
        !io_repo    TYPE REF TO zcl_abapgit_repo
        !is_checks  TYPE zif_abapgit_definitions=>ty_deserialize_checks
      CHANGING
        !ct_results TYPE zif_abapgit_definitions=>ty_results_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS warning_overwrite_find
      IMPORTING
        !it_results         TYPE zif_abapgit_definitions=>ty_results_tt
      RETURNING
        VALUE(rt_overwrite) TYPE zif_abapgit_definitions=>ty_overwrite_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS warning_package_adjust
      IMPORTING
        !io_repo      TYPE REF TO zcl_abapgit_repo
        !it_overwrite TYPE zif_abapgit_definitions=>ty_overwrite_tt
      CHANGING
        !ct_results   TYPE zif_abapgit_definitions=>ty_results_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS warning_package_find
      IMPORTING
        !it_results         TYPE zif_abapgit_definitions=>ty_results_tt
        !io_repo            TYPE REF TO zcl_abapgit_repo
      RETURNING
        VALUE(rt_overwrite) TYPE zif_abapgit_definitions=>ty_overwrite_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS update_package_tree
      IMPORTING
        !iv_package TYPE devclass .
    CLASS-METHODS delete_obj
      IMPORTING
        !is_item TYPE zif_abapgit_definitions=>ty_item
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS compare_remote_to_local
      IMPORTING
        !ii_object TYPE REF TO zif_abapgit_object
        !it_remote TYPE zif_abapgit_definitions=>ty_files_tt
        !is_result TYPE zif_abapgit_definitions=>ty_result
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS deserialize_objects
      IMPORTING
        it_objects TYPE ty_deserialization_tt
        iv_ddic    TYPE abap_bool DEFAULT abap_false
        iv_descr   TYPE string
      CHANGING
        ct_files   TYPE zif_abapgit_definitions=>ty_file_signatures_tt
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS check_objects_locked
      IMPORTING
        iv_language TYPE spras
        it_items    TYPE zif_abapgit_definitions=>ty_items_tt
      RAISING
        zcx_abapgit_exception.
    CLASS-METHODS create_object
      IMPORTING
        is_item        TYPE zif_abapgit_definitions=>ty_item
        iv_language    TYPE spras
        is_metadata    TYPE zif_abapgit_definitions=>ty_metadata OPTIONAL
        iv_native_only TYPE abap_bool DEFAULT abap_false
      RETURNING
        VALUE(ri_obj)  TYPE REF TO zif_abapgit_object
      RAISING
        zcx_abapgit_exception .
    CLASS-METHODS map_tadir_to_items
      IMPORTING
        it_tadir        TYPE zif_abapgit_definitions=>ty_tadir_tt
      RETURNING
        VALUE(rt_items) TYPE zif_abapgit_definitions=>ty_items_tt.
    CLASS-METHODS map_results_to_items
      IMPORTING
        it_results      TYPE zif_abapgit_definitions=>ty_results_tt
      RETURNING
        VALUE(rt_items) TYPE zif_abapgit_definitions=>ty_items_tt.
    CLASS-METHODS filter_files_to_deserialize
      IMPORTING
        it_results        TYPE zif_abapgit_definitions=>ty_results_tt
      RETURNING
        VALUE(rt_results) TYPE zif_abapgit_definitions=>ty_results_tt.
    CLASS-METHODS adjust_namespaces
      IMPORTING
        it_results        TYPE zif_abapgit_definitions=>ty_results_tt
      RETURNING
        VALUE(rt_results) TYPE zif_abapgit_definitions=>ty_results_tt.
ENDCLASS.



CLASS ZCL_ABAPGIT_OBJECTS IMPLEMENTATION.


  METHOD adjust_namespaces.

    FIELD-SYMBOLS: <ls_result> LIKE LINE OF rt_results.

    rt_results = it_results.

    LOOP AT rt_results ASSIGNING <ls_result>.
      REPLACE ALL OCCURRENCES OF '#' IN <ls_result>-obj_name WITH '/'.
    ENDLOOP.

  ENDMETHOD.


  METHOD changed_by.

    DATA: li_obj TYPE REF TO zif_abapgit_object.

    IF is_item IS NOT INITIAL.
      li_obj = create_object( is_item     = is_item
                              iv_language = zif_abapgit_definitions=>c_english ).
      rv_user = li_obj->changed_by( ).
    ENDIF.

    IF rv_user IS INITIAL.
* eg. "".abapgit.xml"" file
      rv_user = zcl_abapgit_objects_super=>c_user_unknown.
    ENDIF.

* todo, fallback to looking at transports if rv_user = 'UNKNOWN'?

  ENDMETHOD.


  METHOD checks_adjust.

    warning_overwrite_adjust(
      EXPORTING it_overwrite = is_checks-overwrite
      CHANGING ct_results = ct_results ).

    warning_package_adjust(
      EXPORTING
        io_repo = io_repo
        it_overwrite = is_checks-warning_package
      CHANGING
        ct_results = ct_results ).

  ENDMETHOD.


  METHOD check_duplicates.

    DATA: lt_files TYPE zif_abapgit_definitions=>ty_files_tt.


    lt_files = it_files.
    SORT lt_files BY path ASCENDING filename ASCENDING.
    DELETE ADJACENT DUPLICATES FROM lt_files COMPARING path filename.
    IF lines( lt_files ) <> lines( it_files ).
      zcx_abapgit_exception=>raise( 'Duplicates' ).
    ENDIF.

  ENDMETHOD.


  METHOD check_objects_locked.

    DATA: li_obj TYPE REF TO zif_abapgit_object.

    FIELD-SYMBOLS: <ls_item> LIKE LINE OF it_items.

    LOOP AT it_items ASSIGNING <ls_item>.

      li_obj = create_object( is_item     = <ls_item>
                              iv_language = iv_language ).

      IF li_obj->is_locked( ) = abap_true.
        zcx_abapgit_exception=>raise( |Object { <ls_item>-obj_type } { <ls_item>-obj_name } |
                                   && |is locked. Action not possible.| ).
      ENDIF.

    ENDLOOP.

  ENDMETHOD.


  METHOD class_name.

    CONCATENATE 'ZCL_ABAPGIT_OBJECT_' is_item-obj_type INTO rv_class_name. ""#EC NOTEXT

  ENDMETHOD.


  METHOD compare_remote_to_local.
* this method is used for comparing local with remote objects
* before pull, this is useful eg. when overwriting a TABL object.
* only the main XML file is used for comparison

    DATA: ls_remote_file       TYPE zif_abapgit_definitions=>ty_file,
          lo_remote_version    TYPE REF TO zcl_abapgit_xml_input,
          lv_count             TYPE i,
          li_comparison_result TYPE REF TO zif_abapgit_comparison_result.


    FIND ALL OCCURRENCES OF '.' IN is_result-filename MATCH COUNT lv_count.

    IF is_result-filename CS '.XML' AND lv_count = 2.
      IF ii_object->exists( ) = abap_false.
        RETURN.
      ENDIF.

      READ TABLE it_remote WITH KEY filename = is_result-filename INTO ls_remote_file.

      ""if file does not exist in remote, we don't need to validate
      IF sy-subrc = 0.
        CREATE OBJECT lo_remote_version
          EXPORTING
            iv_xml = zcl_abapgit_convert=>xstring_to_string_utf8( ls_remote_file-data ).
        li_comparison_result = ii_object->compare_to_remote_version( lo_remote_version ).
        li_comparison_result->show_confirmation_dialog( ).

        IF li_comparison_result->is_result_complete_halt( ) = abap_true.
          zcx_abapgit_exception=>raise( 'Deserialization aborted by user' ).
        ENDIF.
      ENDIF.
    ENDIF.

  ENDMETHOD.


  METHOD create_object.

    DATA: lv_message            TYPE string,
          lv_class_name         TYPE string,
          ls_obj_serializer_map LIKE LINE OF gt_obj_serializer_map.


    READ TABLE gt_obj_serializer_map
      INTO ls_obj_serializer_map WITH KEY item = is_item.
    IF sy-subrc = 0.
      lv_class_name = ls_obj_serializer_map-metadata-class.
    ELSEIF is_metadata IS NOT INITIAL.
*        Metadata is provided only on serialization
*        Once this has been triggered, the same serializer shall be used
*        for subsequent processes.
*        Thus, buffer the metadata afterwards
      ls_obj_serializer_map-item      = is_item.
      ls_obj_serializer_map-metadata  = is_metadata.
      INSERT ls_obj_serializer_map INTO TABLE gt_obj_serializer_map.

      lv_class_name = is_metadata-class.
    ELSE.
      lv_class_name = class_name( is_item ).
    ENDIF.

    REPLACE FIRST OCCURRENCE OF 'LCL' IN lv_class_name WITH 'ZCL_ABAPGIT'.

    TRY.
        CREATE OBJECT ri_obj TYPE (lv_class_name)
          EXPORTING
            is_item     = is_item
            iv_language = iv_language.
      CATCH cx_sy_create_object_error.
        lv_message = |Object type { is_item-obj_type } not supported, serialize|. ""#EC NOTEXT
        IF iv_native_only = abap_false.
          TRY. "" 2nd step, try looking for plugins
              CREATE OBJECT ri_obj TYPE zcl_abapgit_objects_bridge
                EXPORTING
                  is_item = is_item.
            CATCH cx_sy_create_object_error.
              zcx_abapgit_exception=>raise( lv_message ).
          ENDTRY.
        ELSE. "" No native support? -> fail
          zcx_abapgit_exception=>raise( lv_message ).
        ENDIF.
    ENDTRY.

  ENDMETHOD.


  METHOD delete.

    DATA: ls_item     TYPE zif_abapgit_definitions=>ty_item,
          li_progress TYPE REF TO zif_abapgit_progress,
          lt_tadir    LIKE it_tadir,
          lt_items    TYPE zif_abapgit_definitions=>ty_items_tt,
          lx_error    TYPE REF TO zcx_abapgit_exception,
          lv_text     TYPE string.

    FIELD-SYMBOLS: <ls_tadir> LIKE LINE OF it_tadir.

    lt_tadir = it_tadir.

    IF is_checks-transport-required = abap_true.
      zcl_abapgit_default_transport=>get_instance( )->set( is_checks-transport-transport ).
    ENDIF.

    TRY.
        zcl_abapgit_dependencies=>resolve( CHANGING ct_tadir = lt_tadir ).

        li_progress = zcl_abapgit_progress=>get_instance( lines( lt_tadir ) ).

        lt_items = map_tadir_to_items( lt_tadir ).

        check_objects_locked( iv_language = zif_abapgit_definitions=>c_english
                              it_items    = lt_items ).

        LOOP AT lt_tadir ASSIGNING <ls_tadir>.
          li_progress->show( iv_current = sy-tabix
                             iv_text    = |Delete { <ls_tadir>-obj_name }| ) ##NO_TEXT.

          CLEAR ls_item.
          ls_item-obj_type = <ls_tadir>-object.
          ls_item-obj_name = <ls_tadir>-obj_name.
          delete_obj( ls_item ).

* make sure to save object deletions
          COMMIT WORK.
        ENDLOOP.

      CATCH zcx_abapgit_exception INTO lx_error.
        zcl_abapgit_default_transport=>get_instance( )->reset( ).
        lv_text = lx_error->get_text( ).
        zcx_abapgit_exception=>raise( lv_text ).
    ENDTRY.

    zcl_abapgit_default_transport=>get_instance( )->reset( ).

  ENDMETHOD.


  METHOD delete_obj.

    DATA: li_obj TYPE REF TO zif_abapgit_object.


    IF is_supported( is_item ) = abap_true.
      li_obj = create_object( is_item     = is_item
                              iv_language = zif_abapgit_definitions=>c_english ).

      li_obj->delete( ).

      IF li_obj->get_metadata( )-delete_tadir = abap_true.
        CALL FUNCTION 'TR_TADIR_INTERFACE'
          EXPORTING
            wi_delete_tadir_entry = abap_true
            wi_tadir_pgmid        = 'R3TR'
            wi_tadir_object       = is_item-obj_type
            wi_tadir_obj_name     = is_item-obj_name
            wi_test_modus         = abap_false.
      ENDIF.
    ENDIF.

  ENDMETHOD.


  METHOD deserialize.

    DATA: ls_item     TYPE zif_abapgit_definitions=>ty_item,
          li_obj      TYPE REF TO zif_abapgit_object,
          lt_remote   TYPE zif_abapgit_definitions=>ty_files_tt,
          lv_package  TYPE devclass,
          lo_files    TYPE REF TO zcl_abapgit_objects_files,
          lo_xml      TYPE REF TO zcl_abapgit_xml_input,
          lt_results  TYPE zif_abapgit_definitions=>ty_results_tt,
          lt_ddic     TYPE TABLE OF ty_deserialization,
          lt_rest     TYPE TABLE OF ty_deserialization,
          lt_late     TYPE TABLE OF ty_deserialization,
          li_progress TYPE REF TO zif_abapgit_progress,
          lv_path     TYPE string,
          lt_items    TYPE zif_abapgit_definitions=>ty_items_tt.
    DATA: lo_folder_logic TYPE REF TO zcl_abapgit_folder_logic.

    FIELD-SYMBOLS: <ls_result> TYPE zif_abapgit_definitions=>ty_result,
                   <ls_deser>  LIKE LINE OF lt_late.


    lv_package = io_repo->get_package( ).

    IF is_checks-transport-required = abap_true.
      zcl_abapgit_default_transport=>get_instance( )->set( is_checks-transport-transport ).
    ENDIF.

    zcl_abapgit_objects_activation=>clear( ).

    lt_remote = io_repo->get_files_remote( ).

    lt_results = files_to_deserialize( io_repo ).

    checks_adjust(
      EXPORTING
        io_repo    = io_repo
        is_checks  = is_checks
      CHANGING
        ct_results = lt_results ).

    li_progress = zcl_abapgit_progress=>get_instance( lines( lt_results ) ).

    lt_items = map_results_to_items( lt_results ).

    check_objects_locked( iv_language = io_repo->get_dot_abapgit( )->get_master_language( )
                          it_items    = lt_items ).

    lo_folder_logic = zcl_abapgit_folder_logic=>get_instance( ).
    LOOP AT lt_results ASSIGNING <ls_result>.
      li_progress->show( iv_current = sy-tabix
                         iv_text    = |Deserialize { <ls_result>-obj_name }| ) ##NO_TEXT.

      CLEAR ls_item.
      ls_item-obj_type = <ls_result>-obj_type.
      ls_item-obj_name = <ls_result>-obj_name.

      lv_package = lo_folder_logic->path_to_package(
        iv_top  = io_repo->get_package( )
        io_dot  = io_repo->get_dot_abapgit( )
        iv_path = <ls_result>-path ).

      IF ls_item-obj_type = 'DEVC'.
        "" Packages have the same filename across different folders. The path needs to be supplied
        "" to find the correct file.
        lv_path = <ls_result>-path.
      ENDIF.

      CREATE OBJECT lo_files
        EXPORTING
          is_item = ls_item
          iv_path = lv_path.
      lo_files->set_files( lt_remote ).

* Analyze XML in order to instantiate the proper serializer
      lo_xml = lo_files->read_xml( ).

      li_obj = create_object( is_item     = ls_item
                              iv_language = io_repo->get_dot_abapgit( )->get_master_language( )
                              is_metadata = lo_xml->get_metadata( ) ).

      compare_remote_to_local(
        ii_object = li_obj
        it_remote = lt_remote
        is_result = <ls_result> ).

      li_obj->mo_files = lo_files.

      IF li_obj->get_metadata( )-late_deser = abap_true.
        APPEND INITIAL LINE TO lt_late ASSIGNING <ls_deser>.
      ELSEIF li_obj->get_metadata( )-ddic = abap_true.
        APPEND INITIAL LINE TO lt_ddic ASSIGNING <ls_deser>.
      ELSE.
        APPEND INITIAL LINE TO lt_rest ASSIGNING <ls_deser>.
      ENDIF.
      <ls_deser>-item    = ls_item.
      <ls_deser>-obj     = li_obj.
      <ls_deser>-xml     = lo_xml.
      <ls_deser>-package = lv_package.

      CLEAR: lv_path, lv_package.
    ENDLOOP.

    deserialize_objects( EXPORTING it_objects = lt_ddic
                                   iv_ddic    = abap_true
                                   iv_descr   = 'DDIC'
                         CHANGING ct_files = rt_accessed_files ).

    deserialize_objects( EXPORTING it_objects = lt_rest
                                   iv_descr   = 'Objects'
                         CHANGING ct_files = rt_accessed_files ).

    deserialize_objects( EXPORTING it_objects = lt_late
                                   iv_descr   = 'Late'
                         CHANGING ct_files = rt_accessed_files ).

    update_package_tree( io_repo->get_package( ) ).

    SORT rt_accessed_files BY path ASCENDING filename ASCENDING.
    DELETE ADJACENT DUPLICATES FROM rt_accessed_files. "" Just in case

    zcl_abapgit_default_transport=>get_instance( )->reset( ).

  ENDMETHOD.


  METHOD deserialize_checks.

    DATA: lt_results TYPE zif_abapgit_definitions=>ty_results_tt,
          li_package TYPE REF TO zif_abapgit_sap_package.


    lt_results = files_to_deserialize( io_repo ).

    rs_checks-overwrite = warning_overwrite_find( lt_results ).

    rs_checks-warning_package = warning_package_find(
      io_repo    = io_repo
      it_results = lt_results ).

    IF lines( lt_results ) > 0.
      li_package = zcl_abapgit_factory=>get_sap_package( io_repo->get_package( ) ).
      rs_checks-transport-required = li_package->are_changes_recorded_in_tr_req( ).
      IF NOT rs_checks-transport-required IS INITIAL.
        rs_checks-transport-type = li_package->get_transport_type( ).
      ENDIF.
    ENDIF.

  ENDMETHOD.


  METHOD deserialize_objects.

    DATA: li_progress TYPE REF TO zif_abapgit_progress.

    FIELD-SYMBOLS: <ls_obj> LIKE LINE OF it_objects.


    zcl_abapgit_objects_activation=>clear( ).

    li_progress = zcl_abapgit_progress=>get_instance( lines( it_objects ) ).

    LOOP AT it_objects ASSIGNING <ls_obj>.
      li_progress->show(
        iv_current = sy-tabix
        iv_text    = |Deserialize { iv_descr } - { <ls_obj>-item-obj_name }| ) ##NO_TEXT.

      <ls_obj>-obj->deserialize( iv_package = <ls_obj>-package
                                 io_xml     = <ls_obj>-xml ).
      APPEND LINES OF <ls_obj>-obj->mo_files->get_accessed_files( ) TO ct_files.
    ENDLOOP.

    zcl_abapgit_objects_activation=>activate( iv_ddic ).

  ENDMETHOD.


  METHOD exists.

    DATA: li_obj TYPE REF TO zif_abapgit_object.


    TRY.
        li_obj = create_object( is_item = is_item
                                iv_language = zif_abapgit_definitions=>c_english ).
        rv_bool = li_obj->exists( ).
      CATCH zcx_abapgit_exception.
* ignore all errors and assume the object exists
        rv_bool = abap_true.
    ENDTRY.

  ENDMETHOD.


  METHOD files_to_deserialize.

    rt_results = adjust_namespaces(
                   prioritize_deser(
                     filter_files_to_deserialize(
                       zcl_abapgit_file_status=>status( io_repo ) ) ) ).

  ENDMETHOD.


  METHOD filter_files_to_deserialize.

    rt_results = it_results.

    DELETE rt_results WHERE match = abap_true.     "" Full match
    SORT rt_results
      BY obj_type ASCENDING
         obj_name ASCENDING
         rstate   DESCENDING. "" ensures that non-empty rstate is kept
    DELETE ADJACENT DUPLICATES FROM rt_results COMPARING obj_type obj_name.

    DELETE rt_results WHERE obj_type IS INITIAL.
    DELETE rt_results WHERE lstate = zif_abapgit_definitions=>c_state-added AND rstate IS INITIAL.

  ENDMETHOD.


  METHOD has_changed_since.
    rv_changed = abap_true. "" Assume changed

    IF is_supported( is_item ) = abap_false.
      RETURN. "" Will requre serialize which will log the error
    ENDIF.

    rv_changed = create_object(
      is_item     = is_item
      iv_language = zif_abapgit_definitions=>c_english )->has_changed_since( iv_timestamp ).

  ENDMETHOD.


  METHOD is_active.

    DATA: li_object TYPE REF TO zif_abapgit_object.

    TRY.
        li_object = create_object( is_item     = is_item
                                   iv_language = sy-langu ).

        rv_active = li_object->is_active( ).
      CATCH cx_sy_dyn_call_illegal_method
            cx_sy_ref_is_initial
            zcx_abapgit_exception.
        rv_active = abap_true.
    ENDTRY.
  ENDMETHOD.


  METHOD is_supported.

    TRY.
        create_object( is_item        = is_item
                       iv_language    = zif_abapgit_definitions=>c_english
                       iv_native_only = iv_native_only ).
        rv_bool = abap_true.
      CATCH zcx_abapgit_exception.
        rv_bool = abap_false.
    ENDTRY.

  ENDMETHOD.


  METHOD jump.

    DATA: li_obj              TYPE REF TO zif_abapgit_object,
          lv_adt_jump_enabled TYPE abap_bool.

    li_obj = create_object( is_item     = is_item
                            iv_language = zif_abapgit_definitions=>c_english ).

    IF li_obj->exists( ) = abap_false.
      zcx_abapgit_exception=>raise( |Object { is_item-obj_type } { is_item-obj_name } doesn't exist| ).
    ENDIF.

    lv_adt_jump_enabled = zcl_abapgit_persist_settings=>get_instance( )->read( )->get_adt_jump_enabled( ).

    IF lv_adt_jump_enabled = abap_true.
      TRY.
          zcl_abapgit_objects_super=>jump_adt(
            iv_obj_name    = is_item-obj_name
            iv_obj_type    = is_item-obj_type
            iv_line_number = iv_line_number ).
        CATCH zcx_abapgit_exception.
          li_obj->jump( ).
      ENDTRY.
    ELSE.
      li_obj->jump( ).
    ENDIF.

  ENDMETHOD.


  METHOD map_results_to_items.

    DATA: ls_item LIKE LINE OF rt_items.
    FIELD-SYMBOLS: <ls_result> TYPE zif_abapgit_definitions=>ty_result.

    LOOP AT it_results ASSIGNING <ls_result>.

      ls_item-devclass = <ls_result>-package.
      ls_item-obj_type = <ls_result>-obj_type.
      ls_item-obj_name = <ls_result>-obj_name.
      INSERT ls_item INTO TABLE rt_items.

    ENDLOOP.

  ENDMETHOD.


  METHOD map_tadir_to_items.

    DATA: ls_item LIKE LINE OF rt_items.
    FIELD-SYMBOLS: <ls_tadir> TYPE zif_abapgit_definitions=>ty_tadir.

    LOOP AT it_tadir ASSIGNING <ls_tadir>.

      ls_item-devclass = <ls_tadir>-devclass.
      ls_item-obj_type = <ls_tadir>-object.
      ls_item-obj_name = <ls_tadir>-obj_name.
      INSERT ls_item INTO TABLE rt_items.

    ENDLOOP.

  ENDMETHOD.


  METHOD prioritize_deser.

    FIELD-SYMBOLS: <ls_result> LIKE LINE OF it_results.

* XSLT has to be handled before CLAS/PROG
    LOOP AT it_results ASSIGNING <ls_result> WHERE obj_type = 'XSLT'.
      APPEND <ls_result> TO rt_results.
    ENDLOOP.

* PROG before internet services, as the services might use the screens
    LOOP AT it_results ASSIGNING <ls_result> WHERE obj_type = 'PROG'.
      APPEND <ls_result> TO rt_results.
    ENDLOOP.

* ISAP has to be handled before ISRP
    LOOP AT it_results ASSIGNING <ls_result> WHERE obj_type = 'IASP'.
      APPEND <ls_result> TO rt_results.
    ENDLOOP.

* PINF has to be handled before DEVC for package interface usage
    LOOP AT it_results ASSIGNING <ls_result> WHERE obj_type = 'PINF'.
      APPEND <ls_result> TO rt_results.
    ENDLOOP.

* ENHS has to be handled before ENHO
    LOOP AT it_results ASSIGNING <ls_result> WHERE obj_type = 'ENHS'.
      APPEND <ls_result> TO rt_results.
    ENDLOOP.

* DDLS has to be handled before DCLS
    LOOP AT it_results ASSIGNING <ls_result> WHERE obj_type = 'DDLS'.
      APPEND <ls_result> TO rt_results.
    ENDLOOP.

    LOOP AT it_results ASSIGNING <ls_result>
        WHERE obj_type <> 'IASP'
        AND obj_type <> 'PROG'
        AND obj_type <> 'XSLT'
        AND obj_type <> 'PINF'
        AND obj_type <> 'ENHS'
        AND obj_type <> 'DDLS'.
      APPEND <ls_result> TO rt_results.
    ENDLOOP.

  ENDMETHOD.


  METHOD serialize.

    DATA: li_obj   TYPE REF TO zif_abapgit_object,
          lo_xml   TYPE REF TO zcl_abapgit_xml_output,
          lo_files TYPE REF TO zcl_abapgit_objects_files.

    FIELD-SYMBOLS: <ls_file> LIKE LINE OF rs_files_and_item-files.

    rs_files_and_item-item = is_item.

    IF is_supported( rs_files_and_item-item ) = abap_false.
      zcx_abapgit_exception=>raise( |Object type ignored, not supported: {
        rs_files_and_item-item-obj_type }-{
        rs_files_and_item-item-obj_name }| ).
    ENDIF.

    CREATE OBJECT lo_files
      EXPORTING
        is_item = rs_files_and_item-item.

    li_obj = create_object( is_item     = rs_files_and_item-item
                            iv_language = iv_language ).
    li_obj->mo_files = lo_files.
    CREATE OBJECT lo_xml.
    li_obj->serialize( lo_xml ).
    lo_files->add_xml( io_xml      = lo_xml
                       is_metadata = li_obj->get_metadata( ) ).

    rs_files_and_item-files = lo_files->get_files( ).

    check_duplicates( rs_files_and_item-files ).

    rs_files_and_item-item-inactive = boolc( li_obj->is_active( ) = abap_false ).

    LOOP AT rs_files_and_item-files ASSIGNING <ls_file>.
      <ls_file>-sha1 = zcl_abapgit_hash=>sha1(
        iv_type = zif_abapgit_definitions=>c_type-blob
        iv_data = <ls_file>-data ).
    ENDLOOP.

  ENDMETHOD.


  METHOD supported_list.

    DATA: lt_objects   TYPE STANDARD TABLE OF ko100,
          lv_supported TYPE abap_bool,
          ls_item      TYPE zif_abapgit_definitions=>ty_item.

    FIELD-SYMBOLS <ls_object> LIKE LINE OF lt_objects.


    CALL FUNCTION 'TR_OBJECT_TABLE'
      TABLES
        wt_object_text = lt_objects
      EXCEPTIONS
        OTHERS         = 1 ##FM_SUBRC_OK.

    LOOP AT lt_objects ASSIGNING <ls_object> WHERE pgmid = 'R3TR'.
      ls_item-obj_type = <ls_object>-object.

      lv_supported = zcl_abapgit_objects=>is_supported(
        is_item        = ls_item
        iv_native_only = abap_true ).

      IF lv_supported = abap_true.
        APPEND <ls_object>-object TO rt_types.
      ENDIF.
    ENDLOOP.

  ENDMETHOD.


  METHOD update_package_tree.

    DATA: lt_packages TYPE zif_abapgit_sap_package=>ty_devclass_tt,
          lv_package  LIKE LINE OF lt_packages,
          lv_tree     TYPE dirtree-tname.


    lt_packages = zcl_abapgit_factory=>get_sap_package( iv_package )->list_subpackages( ).
    APPEND iv_package TO lt_packages.

    LOOP AT lt_packages INTO lv_package.
* update package tree for SE80
      lv_tree = 'EU_' && lv_package.
      CALL FUNCTION 'WB_TREE_ACTUALIZE'
        EXPORTING
          tree_name              = lv_tree
          without_crossreference = abap_true
          with_tcode_index       = abap_true.
    ENDLOOP.

  ENDMETHOD.


  METHOD warning_overwrite_adjust.

    DATA: lt_overwrite LIKE it_overwrite,
          ls_overwrite LIKE LINE OF lt_overwrite.

    FIELD-SYMBOLS: <ls_overwrite> LIKE LINE OF lt_overwrite.


* make sure to get the current status, as something might have changed in the meanwhile
    lt_overwrite = warning_overwrite_find( ct_results ).

    LOOP AT lt_overwrite ASSIGNING <ls_overwrite>.

      READ TABLE it_overwrite INTO ls_overwrite
                              WITH TABLE KEY object_type_and_name
                              COMPONENTS obj_type = <ls_overwrite>-obj_type
                                         obj_name = <ls_overwrite>-obj_name.
      IF sy-subrc <> 0 OR ls_overwrite-decision IS INITIAL.
        zcx_abapgit_exception=>raise( |Overwrite { <ls_overwrite>-obj_type } {
          <ls_overwrite>-obj_name } undecided| ).
      ENDIF.

      IF ls_overwrite-decision = 'N'.
        DELETE ct_results WHERE
          obj_type = <ls_overwrite>-obj_type AND
          obj_name = <ls_overwrite>-obj_name.
        ASSERT sy-subrc = 0.
      ENDIF.

    ENDLOOP.

  ENDMETHOD.


  METHOD warning_overwrite_find.

    DATA: ls_overwrite LIKE LINE OF rt_overwrite.

    FIELD-SYMBOLS: <ls_result> LIKE LINE OF it_results.

    LOOP AT it_results ASSIGNING <ls_result>
        WHERE NOT obj_type IS INITIAL.
      IF <ls_result>-lstate IS NOT INITIAL
          AND <ls_result>-lstate <> zif_abapgit_definitions=>c_state-deleted
          AND NOT ( <ls_result>-lstate = zif_abapgit_definitions=>c_state-added
          AND <ls_result>-rstate IS INITIAL ).
* current object has been modified locally, add to table
        CLEAR ls_overwrite.
        MOVE-CORRESPONDING <ls_result> TO ls_overwrite.
        APPEND ls_overwrite TO rt_overwrite.
      ENDIF.
    ENDLOOP.

    SORT rt_overwrite.
    DELETE ADJACENT DUPLICATES FROM rt_overwrite.

  ENDMETHOD.


  METHOD warning_package_adjust.

    DATA: lt_overwrite LIKE it_overwrite,
          ls_overwrite LIKE LINE OF lt_overwrite.

    FIELD-SYMBOLS: <ls_overwrite> LIKE LINE OF lt_overwrite.


* make sure to get the current status, as something might have changed in the meanwhile
    lt_overwrite = warning_package_find(
      it_results   = ct_results
      io_repo      = io_repo ).

    LOOP AT lt_overwrite ASSIGNING <ls_overwrite>.

      READ TABLE it_overwrite INTO ls_overwrite
                              WITH TABLE KEY object_type_and_name
                              COMPONENTS obj_type = <ls_overwrite>-obj_type
                                         obj_name = <ls_overwrite>-obj_name.
      IF sy-subrc <> 0 OR ls_overwrite-decision IS INITIAL.
        zcx_abapgit_exception=>raise( |Overwrite odd package { <ls_overwrite>-obj_type } {
          <ls_overwrite>-obj_name } undecided| ).
      ENDIF.

      IF ls_overwrite-decision = 'N'.
        DELETE ct_results WHERE
          obj_type = <ls_overwrite>-obj_type AND
          obj_name = <ls_overwrite>-obj_name.
        ASSERT sy-subrc = 0.
      ENDIF.

    ENDLOOP.

  ENDMETHOD.


  METHOD warning_package_find.

    DATA: lv_package         TYPE devclass,
          lt_overwrite_uniqe TYPE HASHED TABLE OF zif_abapgit_definitions=>ty_overwrite
                                  WITH UNIQUE KEY obj_type obj_name devclass,
          ls_overwrite       LIKE LINE OF rt_overwrite,
          ls_tadir           TYPE zif_abapgit_definitions=>ty_tadir.

    DATA: lo_folder_logic TYPE REF TO zcl_abapgit_folder_logic.

    FIELD-SYMBOLS: <ls_result> LIKE LINE OF it_results.

    lo_folder_logic = zcl_abapgit_folder_logic=>get_instance( ).
    LOOP AT it_results ASSIGNING <ls_result>.

      lv_package = lo_folder_logic->path_to_package(
        iv_top  = io_repo->get_package( )
        io_dot  = io_repo->get_dot_abapgit( )
        iv_path = <ls_result>-path ).

      ls_tadir = zcl_abapgit_factory=>get_tadir( )->read_single(
        iv_object   = <ls_result>-obj_type
        iv_obj_name = <ls_result>-obj_name ).

      IF NOT ls_tadir IS INITIAL AND ls_tadir-devclass <> lv_package.
* overwriting object from different package than expected
        CLEAR ls_overwrite.
        ls_overwrite-obj_type = <ls_result>-obj_type.
        ls_overwrite-obj_name = <ls_result>-obj_name.
        ls_overwrite-devclass = ls_tadir-devclass.
        INSERT ls_overwrite INTO TABLE lt_overwrite_uniqe.
      ENDIF.

    ENDLOOP.

    rt_overwrite = lt_overwrite_uniqe.

  ENDMETHOD.
ENDCLASS.
",8462,False,1860.145459168437,median
"// Use these for links to issue and pulls. Note issues and pulls redirect one to
// each other on Github, so don't worry too much on using the right prefix.
:issue: https://github.com/elastic/beats/issues/
:pull: https://github.com/elastic/beats/pull/

=== Beats version HEAD
https://github.com/elastic/beats/compare/v7.0.0-alpha2...master[Check the HEAD diff]

==== Breaking changes

*Affecting all Beats*

- Update to Golang 1.12.1. {pull}11330[11330]
- Update to Golang 1.12.4. {pull}11782[11782]
- Update to ECS 1.0.1. {pull}12284[12284] {pull}12317[12317]
- Default of output.kafka.metadata.full is set to false by now. This reduced the amount of metadata to be queried from a kafka cluster. {pull}12738[12738]
- Fixed a crash under Windows when fetching processes information. {pull}12833[12833]
- Update to Golang 1.12.7. {pull}12931[12931]
- Remove `in_cluster` configuration parameter for Kuberentes, now in-cluster configuration is used only if no other kubeconfig is specified {pull}13051[13051]
- Disable Alibaba Cloud and Tencent Cloud metadata providers by default. {pull}13812[12812]
- Libbeat HTTP's Server can listen to a unix socket using the `unix:///tmp/hello.sock` syntax. {pull}13655[13655]
- Libbeat HTTP's Server can listen to a Windows named pipe using the `npipe:///hello` syntax. {pull}13655[13655]

*Auditbeat*

- Auditd module: Normalized value of `event.category` field from `user-login` to `authentication`. {pull}11432[11432]
- Auditd module: Unset `auditd.session` and `user.audit.id` fields are removed from audit events. {issue}11431[11431] {pull}11815[11815]
- Socket dataset: Exclude localhost by default {pull}11993[11993]
- Socket dataset: New implementation using Kprobes for finer-grained monitoring and UDP support. {pull}13058[13058]

*Filebeat*

- Add read_buffer configuration option. {pull}11739[11739]
- `convert_timezone` option is removed and locale is always added to the event so timezone is used when parsing the timestamp, this behaviour can be overriden with processors. {pull}12410[12410]
- Fix a race condition in the TCP input when close the client socket. {pull}13038[13038]
- cisco/asa fileset: Renamed log.original to event.original and cisco.asa.list_id to cisco.asa.rule_name. {pull}13286[13286]
- cisco/asa fileset: Fix parsing of 302021 message code. {pull}13476[13476]
- Add support for gzipped files in S3 input {pull}13980[13980]

*Heartbeat*

- Removed the `add_host_metadata` and `add_cloud_metadata` processors from the default config. These don't fit well with ECS for Heartbeat and were rarely used.

*Journalbeat*

*Metricbeat*

- Add new dashboards for Azure vms, vm guest metrics, vm scale sets {pull}14000[14000]
- Add new Dashboard for PostgreSQL database stats {pull}13187[13187]
- Add new dashboard for CouchDB database {pull}13198[13198]
- Add new dashboard for Ceph cluster stats {pull}13216[13216]
- Add new dashboard for Aerospike database stats {pull}13217[13217]
- Add new dashboard for Couchbase cluster stats {pull}13212[13212]
- Add new dashboard for Prometheus server stats {pull}13126[13126]
- Add new option `OpMultiplyBuckets` to scale histogram buckets to avoid decimal points in final events {pull}10994[10994]
- system/raid metricset now uses /sys/block instead of /proc/mdstat for data. {pull}11613[11613]
- kubernetes.container.cpu.limit.cores and kubernetes.container.cpu.requests.cores are now floats. {issue}11975[11975]
- Add statistic option into cloudwatch metricset. If there is no statistic method specified, default is to collect Average, Sum, Maximum, Minimum and SampleCount. {issue}12370[12370] {pull}12840[12840]

*Packetbeat*

- Add support for mongodb opcode 2013 (OP_MSG). {issue}6191[6191] {pull}8594[8594]
- NFSv4: Always use opname `ILLEGAL` when failed to match request to a valid nfs operation. {pull}11503[11503]

*Winlogbeat*

*Functionbeat*

- Separate management and functions in Functionbeat. {pull}12939[12939]

==== Bugfixes

*Affecting all Beats*

- Fix typo in TLS renegotiation configuration and setting the option correctly {issue}10871[10871], {pull}12354[12354]
- Ensure all beat commands respect configured settings. {pull}10721[10721]
- Add missing fields and test cases for libbeat add_kubernetes_metadata processor. {issue}11133[11133], {pull}11134[11134]
- decode_json_field: process objects and arrays only {pull}11312[11312]
- decode_json_field: do not process arrays when flag not set. {pull}11318[11318]
- Report faulting file when config reload fails. {pull}11304[11304]
- Fix a typo in libbeat/outputs/transport/client.go by updating `c.conn.LocalAddr()` to `c.conn.RemoteAddr()`. {pull}11242[11242]
- Management configuration backup file will now have a timestamps in their name. {pull}11034[11034]
- [CM] Parse enrollment_token response correctly {pull}11648[11648]
- Not hiding error in case of http failure using elastic fetcher {pull}11604[11604]
- Escape BOM on JsonReader before trying to decode line {pull}11661[11661]
- Fix matching of string arrays in contains condition. {pull}11691[11691]
- Replace wmi queries with win32 api calls as they were consuming CPU resources {issue}3249[3249] and {issue}11840[11840]
- Fix a race condition with the Kafka pipeline client, it is possible that `Close()` get called before `Connect()` . {issue}11945[11945]
- Fix queue.spool.write.flush.events config type. {pull}12080[12080]
- Fixed a memory leak when using the add_process_metadata processor under Windows. {pull}12100[12100]
- Fix of docker json parser for missing ""log"" jsonkey in docker container's log {issue}11464[11464]
- Fixed Beat ID being reported by GET / API. {pull}12180[12180]
- Fixed setting bulk max size in kafka output. {pull}12254[12254]
- Add host.os.codename to fields.yml. {pull}12261[12261]
- Fix `@timestamp` being duplicated in events if `@timestamp` is set in a
  processor (or by any code utilizing `PutValue()` on a `beat.Event`).
- Fix leak in script processor when using Javascript functions in a processor chain. {pull}12600[12600]
- Add additional nil pointer checks to Docker client code to deal with vSphere Integrated Containers {pull}12628[12628]
- Fixed `json.add_error_key` property setting for delivering error messages from beat events  {pull}11298[11298]
- Fix Central Management enroll under Windows {issue}12797[12797] {pull}12799[12799]
- ILM: Use GET instead of HEAD when checking for alias to expose detailed error message. {pull}12886[12886]
- Fix seccomp policy preventing some features to function properly on 32bit Linux systems. {issue}12990[12990] {pull}13008[13008]
- Fix unexpected stops on docker autodiscover when a container is restarted before `cleanup_timeout`. {issue}12962[12962] {pull}13127[13127]
- Fix install-service.ps1's ability to set Windows service's delay start configuration. {pull}13173[13173]
- Fix some incorrect types and formats in field.yml files. {pull}13188[13188]
- Load DLLs only from Windows system directory. {pull}13234[13234] {pull}13384[13384]
- Fix mapping for kubernetes.labels and kubernetes.annotations in add_kubernetes_metadata. {issue}12638[12638] {pull}13226[13226]
- Fix case insensitive regular expressions not working correctly. {pull}13250[13250]
- Disable `add_kubernetes_metadata` if no matchers found. {pull}13709[13709]
- Better wording for xpack beats when the _xpack endpoint is not reachable. {pull}13771[13771]
- Recover from panics in the javascript process and log details about the failure to aid in future debugging. {pull}13690[13690]
- Make the script processor concurrency-safe. {issue}13690[13690] {pull}13857[13857]
- Kubernetes watcher at `add_kubernetes_metadata` fails with StatefulSets {pull}13905[13905]

*Auditbeat*

- Process dataset: Fixed a memory leak under Windows. {pull}12100[12100]
- Login dataset: Fix re-read of utmp files. {pull}12028[12028]
- Package dataset: Fixed a crash inside librpm after Auditbeat has been running for a while. {issue}12147[12147] {pull}12168[12168]
- Fix formatting of config files on macOS and Windows. {pull}12148[12148]
- Fix direction of incoming IPv6 sockets. {pull}12248[12248]
- Package dataset: Close librpm handle. {pull}12215[12215]
- Package dataset: Auto-detect package directories. {pull}12289[12289]
- Package dataset: Improve dpkg parsing. {pull}12325[12325]
- System module: Start system module without host ID. {pull}12373[12373]
- Host dataset: Fix reboot detection logic. {pull}12591[12591]
- Add syscalls used by librpm for the system/package dataset to the default Auditbeat seccomp policy. {issue}12578[12578] {pull}12617[12617]
- Process dataset: Do not show non-root warning on Windows. {pull}12740[12740]
- Host dataset: Export Host fields to gob encoder. {pull}12940[12940]
- Socket dataset: Fix start errors when IPv6 is disabled on the kernel. {issue}13953[13953] {pull}13966[13966]

*Filebeat*

- Add support for Cisco syslog format used by their switch. {pull}10760[10760]
- Cover empty request data, url and version in Apache2 module{pull}10730[10730]
- Fix registry entries not being cleaned due to race conditions. {pull}10747[10747]
- Improve detection of file deletion on Windows. {pull}10747[10747]
- Add missing Kubernetes metadata fields to Filebeat CoreDNS module, and fix a documentation error. {pull}11591[11591]
- Reduce memory usage if long lines are truncated to fit `max_bytes` limit. The line buffer is copied into a smaller buffer now. This allows the runtime to release unused memory earlier. {pull}11524[11524]
- Fix memory leak in Filebeat pipeline acker. {pull}12063[12063]
- Fix goroutine leak caused on initialization failures of log input. {pull}12125[12125]
- Fix goroutine leak on non-explicit finalization of log input. {pull}12164[12164]
- Skipping unparsable log entries from docker json reader {pull}12268[12268]
- Parse timezone in PostgreSQL logs as part of the timestamp {pull}12338[12338]
- Load correct pipelines when system module is configured in modules.d. {pull}12340[12340]
- Fix timezone offset parsing in system/syslog. {pull}12529[12529]
- When TLS is configured for the TCP input and a `certificate_authorities` is configured we now default to `required` for the `client_authentication`. {pull}12584[12584]
- Apply `max_message_size` to incoming message buffer. {pull}11966[11966]
- Syslog input will now omit the `process` object from events if it is empty. {pull}12700[12700]
- Fix multiline pattern in Postgres which was too permissive {issue}12078[12078] {pull}13069[13069]
- Allow path variables to be used in files loaded from modules.d. {issue}13184[13184]
- Fix filebeat autodiscover fileset hint for container input. {pull}13296[13296]
- Fix incorrect references to index patterns in AWS and CoreDNS dashboards. {pull}13303[13303]
- Fix timezone parsing of system module ingest pipelines. {pull}13308[13308]
- Fix timezone parsing of elasticsearch module ingest pipelines. {pull}13367[13367]
- Change iis url path grok pattern from URIPATH to NOTSPACE. {issue}12710[12710] {pull}13225[13225] {issue}7951[7951] {pull}13378[13378]
- Fix timezone parsing of nginx module ingest pipelines. {pull}13369[13369]
- Fix incorrect field references in envoyproxy dashboard {issue}13420[13420] {pull}13421[13421]
- Fixed early expiration of templates (Netflow v9 and IPFIX). {pull}13821[13821]
- Fixed bad handling of sequence numbers when multiple observation domains were exported by a single device (Netflow V9 and IPFIX). {pull}13821[13821]
- Fix timezone parsing of rabbitmq module ingest pipelines. {pull}13879[13879]
- Fix conditions and error checking of date processors in ingest pipelines that use `event.timezone` to parse dates. {pull}13883[13883]
- Fix timezone parsing of Cisco module ingest pipelines. {pull}13893[13893]
- Fix timezone parsing of logstash module ingest pipelines. {pull}13890[13890]
- cisco asa and ftd filesets: Fix parsing of message 106001. {issue}13891[13891] {pull}13903[13903]
- Fix timezone parsing of iptables, mssql and panw module ingest pipelines. {pull}13926[13926]
- Fix merging of fields specified in global scope with fields specified under an input's scope. {issue}3628[3628] {pull}13909[13909]
- Fix delay in enforcing close_renamed and close_removed options. {issue}13488[13488] {pull}13907[13907]
- Fix missing netflow fields in index template. {issue}13768[13768] {pull}13914[13914]
- Fix cisco module's asa and ftd filesets parsing of domain names where an IP address is expected. {issue}14034[14034]
- Fixed increased memory usage with large files when multiline pattern does not match. {issue}14068[14068]

*Heartbeat*

- Fix NPEs / resource leaks when executing config checks. {pull}11165[11165]
- Fix duplicated IPs on `mode: all` monitors. {pull}12458[12458]
- Fix integer comparison on JSON responses. {pull}13348[13348]

*Journalbeat*

- Use backoff when no new events are found. {pull}11861[11861]
- Iterate over journal correctly, so no duplicate entries are sent. {pull}12716[12716]
- Preserve host name when reading from remote journal. {pull}12714[12714]

*Metricbeat*

- Change diskio metrics retrieval method (only for Windows) from wmi query to DeviceIOControl function using the IOCTL_DISK_PERFORMANCE control code {pull}11635[11635]
- Call GetMetricData api per region instead of per instance. {issue}11820[11820] {pull}11882[11882]
- Update documentation with cloudwatch:ListMetrics permission. {pull}11987[11987]
- Check permissions in system socket metricset based on capabilities. {pull}12039[12039]
- Get process information from sockets owned by current user when system socket metricset is run without privileges. {pull}12039[12039]
- Avoid generating hints-based configuration with empty hosts when no exposed port is suitable for the hosts hint. {issue}8264[8264] {pull}12086[12086]
- Fixed a socket leak in the postgresql module under Windows when SSL is disabled on the server. {pull}11393[11393]
- Change some field type from scaled_float to long in aws module. {pull}11982[11982]
- Fixed RabbitMQ `queue` metricset gathering when `consumer_utilisation` is set empty at the metrics source {pull}12089[12089]
- Fix direction of incoming IPv6 sockets. {pull}12248[12248]
- Refactored Windows perfmon metricset: replaced method to retrieve counter paths with PdhExpandWildCardPathW, separated code by responsibility, removed unused functions {pull}12212[12212]
- Validate that kibana/status metricset cannot be used when xpack is enabled. {pull}12264[12264]
- Ignore prometheus metrics when their values are NaN or Inf. {pull}12084[12084] {issue}10849[10849]
- In the kibana/stats metricset, only log error (don't also index it) if xpack is enabled. {pull}12265[12265]
- Fix an issue listing all processes when run under Windows as a non-privileged user. {issue}12301[12301] {pull}12475[12475]
- The `elasticsearch/index_summary` metricset gracefully handles an empty Elasticsearch cluster when `xpack.enabled: true` is set. {pull}12489[12489] {issue}12487[12487]
- When TLS is configured for the http metricset and a `certificate_authorities` is configured we now default to `required` for the `client_authentication`. {pull}12584[12584]
- Reuse connections in PostgreSQL metricsets. {issue}12504[12504] {pull}12603[12603]
- PdhExpandWildCardPathW will not expand counter paths in 32 bit windows systems, workaround will use a different function. {issue}12590[12590] {pull}12622[12622]
- In the elasticsearch/node_stats metricset, if xpack is enabled, make parsing of ES node load average optional as ES on Windows doesn't report load average. {pull}12866[12866]
- Ramdisk is not filtered out when collecting disk performance counters in diskio metricset {issue}12814[12814] {pull}12829[12829]
- Fix incoherent behaviour in redis key metricset when keyspace is specified both in host URL and key pattern {pull}12913[12913]
- Fix connections leak in redis module {pull}12914[12914] {pull}12950[12950]
- Fix wrong uptime reporting by system/uptime metricset under Windows. {pull}12915[12915]
- Print errors that were being omitted in vSphere metricsets. {pull}12816[12816]
- Fix redis key metricset dashboard references to index pattern. {pull}13303[13303]
- Check if fields in DBInstance is nil in rds metricset. {pull}13294[13294] {issue}13037[13037]
- Fix silent failures in kafka and prometheus module. {pull}13353[13353] {issue}13252[13252]
- Fix issue with aws cloudwatch module where dimensions and/or namespaces that contain space are not being parsed correctly {pull}13389[13389]
- Fix panic in Redis Key metricset when collecting information from a removed key. {pull}13426[13426]
- Fix module-level fields in Kubernetes metricsets. {pull}13433[13433] {pull}13544[13544]
- Fix reporting empty events in cloudwatch metricset. {pull}13458[13458]
- Fix `docker.cpu.system.pct` calculation by using the reported number online cpus instead of the number of metrics per cpu. {pull}13691[13691]
- Fix rds metricset dashboard. {pull}13721[13721]
- Ignore prometheus untyped metrics with NaN value. {issue}13750[13750] {pull}13790[13790]
- Change kubernetes.event.message to text {pull}13964[13964]

*Packetbeat*

- Prevent duplicate packet loss error messages in HTTP events. {pull}10709[10709]
- Fixed a memory leak when using process monitoring under Windows. {pull}12100[12100]
- Improved debug logging efficiency in PGQSL module. {issue}12150[12150]
- Limit memory usage of Redis replication sessions. {issue}12657[12657]
- Fix parsing the extended RCODE in the DNS parser. {pull}12805[12805]

*Winlogbeat*

- Fix data race affecting config validation at startup. {issue}13005[13005]

*Functionbeat*

- Fix function name reference for Kinesis streams in CloudFormation templates {pull}11646[11646]
- Fix Cloudwatch logs timestamp to use timestamp of the log record instead of when the record was processed {pull}13291[13291]
- Look for the keystore under the correct path. {pull}13332[13332]

==== Added

*Affecting all Beats*

- Decouple Debug logging from fail_on_error logic for rename, copy, truncate processors {pull}12451[12451]
- Add an option to append to existing logs rather than always rotate on start. {pull}11953[11953]
- Add `network` condition to processors for matching IP addresses against CIDRs. {pull}10743[10743]
- Add if/then/else support to processors. {pull}10744[10744]
- Add `community_id` processor for computing network flow hashes. {pull}10745[10745]
- Add output test to kafka output {pull}10834[10834]
- Gracefully shut down on SIGHUP {pull}10704[10704]
- New processor: `copy_fields`. {pull}11303[11303]
- Add `error.message` to events when `fail_on_error` is set in `rename` and `copy_fields` processors. {pull}11303[11303]
- New processor: `truncate_fields`. {pull}11297[11297]
- Allow a beat to ship monitoring data directly to an Elasticsearch monitoring cluster. {pull}9260[9260]
- Updated go-seccomp-bpf library to v1.1.0 which updates syscall lists for Linux v5.0. {pull}11394[11394]
- Add `add_observer_metadata` processor. {pull}11394[11394]
- Add `decode_csv_fields` processor. {pull}11753[11753]
- Add `convert` processor for converting data types of fields. {issue}8124[8124] {pull}11686[11686]
- New `extract_array` processor. {pull}11761[11761]
- Add number of goroutines to reported metrics. {pull}12135[12135]
- Add `proxy_disable` output flag to explicitly ignore proxy environment variables. {issue}11713[11713] {pull}12243[12243]
- Processor `add_cloud_metadata` adds fields `cloud.account.id` and `cloud.image.id` for AWS EC2. {pull}12307[12307]
- Add configurable bulk_flush_frequency in kafka output. {pull}12254[12254]
- Add `decode_base64_field` processor for decoding base64 field. {pull}11914[11914]
- Add support for reading the `network.iana_number` field by default to the community_id processor. {pull}12701[12701]
- Add aws overview dashboard. {issue}11007[11007] {pull}12175[12175]
- Add `decompress_gzip_field` processor. {pull}12733[12733]
- Add `timestamp` processor for parsing time fields. {pull}12699[12699]
- Fail with error when autodiscover providers have no defined configs. {pull}13078[13078]
- Add a check so alias creation explicitely fails if there is an index with the same name. {pull}13070[13070]
- Update kubernetes watcher to use official client-go libraries. {pull}13051[13051]
- Add support for unix epoch time values in the `timestamp` processor. {pull}13319[13319]
- add_host_metadata is now GA. {pull}13148[13148]
- Add an `ignore_missing` configuration option the `drop_fields` processor. {pull}13318[13318]
- add_host_metadata is no GA. {pull}13148[13148]
- Add `registered_domain` processor for deriving the registered domain from a given FQDN. {pull}13326[13326]
- Add support for RFC3339 time zone offsets in JSON output. {pull}13227[13227]
- Add autodetection mode for add_docker_metadata and enable it by default in included configuration files{pull}13374[13374]
- Added `monitoring.cluster_uuid` setting to associate Beat data with specified ES cluster in Stack Monitoring UI. {pull}13182[13182]
- Add autodetection mode for add_kubernetes_metadata and enable it by default in included configuration files. {pull}13473[13473]
- Add `providers` setting to `add_cloud_metadata` processor. {pull}13812[13812]
- Use less restrictive API to check if template exists. {pull}13847[13847]
- Do not check for alias when setup.ilm.check_exists is false. {pull}13848[13848]
- Add support for numeric time zone offsets in timestamp processor. {pull}13902[13902]
- Add condition to the config file template for add_kubernetes_metadata {pull}14056[14056]
- Marking Central Management deprecated. {pull}14018[14018]
- Add `keep_null` setting to allow Beats to publish null values in events. {issue}5522[5522] {pull}13928[13928]

*Auditbeat*

- Auditd module: Add `event.outcome` and `event.type` for ECS. {pull}11432[11432]
- Process: Add file hash of process executable. {pull}11722[11722]
- Socket: Add network.transport and network.community_id. {pull}12231[12231]
- Host: Fill top-level host fields. {pull}12259[12259]
- Socket: Add DNS enrichment. {pull}14004[14004]

*Filebeat*

- Add more info to message logged when a duplicated symlink file is found {pull}10845[10845]
- Add option to configure docker input with paths {pull}10687[10687]
- Add Netflow module to enrich flow events with geoip data. {pull}10877[10877]
- Set `event.category: network_traffic` for Suricata. {pull}10882[10882]
- Allow custom default settings with autodiscover (for example, use of CRI paths for logs). {pull}12193[12193]
- Allow to disable hints based autodiscover default behavior (fetching all logs). {pull}12193[12193]
- Change Suricata module pipeline to handle `destination.domain` being set if a reverse DNS processor is used. {issue}10510[10510]
- Add the `network.community_id` flow identifier to field to the IPTables, Suricata, and Zeek modules. {pull}11005[11005]
- New Filebeat coredns module to ingest coredns logs. It supports both native coredns deployment and coredns deployment in kubernetes. {pull}11200[11200]
- New module for Cisco ASA logs. {issue}9200[9200] {pull}11171[11171]
- Added support for Cisco ASA fields to the netflow input. {pull}11201[11201]
- Configurable line terminator. {pull}11015[11015]
- Add Filebeat envoyproxy module. {pull}11700[11700]
- Add apache2(httpd) log path (`/var/log/httpd`) to make apache2 module work out of the box on Redhat-family OSes. {issue}11887[11887] {pull}11888[11888]
- Add support to new MongoDB additional diagnostic information {pull}11952[11952]
- New module `panw` for Palo Alto Networks PAN-OS logs. {pull}11999[11999]
- Add RabbitMQ module. {pull}12032[12032]
- Add new `container` input. {pull}12162[12162]
- Add timeouts on communication with docker daemon. {pull}12310[12310]
- `container` and `docker` inputs now support reading of labels and env vars written by docker JSON file logging driver. {issue}8358[8358]
- Add specific date processor to convert timezones so same pipeline can be used when convert_timezone is enabled or disabled. {pull}12253[12253]
- Add MSSQL module {pull}12079[12079]
- Add ISO8601 date parsing support for system module. {pull}12568[12568] {pull}12578[12579]
- Update Kubernetes deployment manifest to use `container` input. {pull}12632[12632]
- Use correct OS path separator in `add_kubernetes_metadata` to support Windows nodes. {pull}9205[9205]
- Add support for virtual host in Apache access logs {pull}12778[12778]
- Add support for client addresses with port in Apache error logs {pull}12695[12695]
- Add `google-pubsub` input type for consuming messages from a Google Cloud Pub/Sub topic subscription. {pull}12746[12746]
- Add module for ingesting Cisco IOS logs over syslog. {pull}12748[12748]
- Add module for ingesting Google Cloud VPC flow logs. {pull}12747[12747]
- Report host metadata for Filebeat logs in Kubernetes. {pull}12790[12790]
- Add netflow dashboards based on Logstash netflow. {pull}12857[12857]
- Parse more fields from Elasticsearch slowlogs. {pull}11939[11939]
- Update module pipelines to enrich events with autonomous system fields. {pull}13036[13036]
- Add module for ingesting IBM MQ logs. {pull}8782[8782]
- Add S3 input to retrieve logs from AWS S3 buckets. {pull}12640[12640] {issue}12582[12582]
- Add aws module s3access metricset. {pull}13170[13170] {issue}12880[12880]
- Update Suricata module to populate ECS DNS fields and handle EVE DNS version 2. {issue}13320[13320] {pull}13329[13329]
- Update PAN-OS fileset to use the ECS NAT fields. {issue}13320[13320] {pull}13330[13330]
- Add fields to the Zeek DNS fileset for ECS DNS. {issue}13320[13320] {pull}13324[13324]
- Add container image in Kubernetes metadata {pull}13356[13356] {issue}12688[12688]
- Add timezone information to apache error fileset. {issue}12772[12772] {pull}13304[13304]
- Add module for ingesting Cisco FTD logs over syslog. {pull}13286[13286]
- Update CoreDNS module to populate ECS DNS fields. {issue}13320[13320] {pull}13505[13505]
- Parse query steps in PostgreSQL slowlogs. {issue}13496[13496] {pull}13701[13701]
- Add filebeat azure module with activitylogs, auditlogs, signinlogs filesets. {pull}13776[13776]
- Add support to set the document id in the json reader. {pull}5844[5844]
- Add input httpjson. {issue}13545[13545] {pull}13546[13546]
- Filebeat Netflow input: Remove beta label. {pull}13858[13858]
- Remove `event.timezone` from events that don't need it in some modules that support log formats with and without timezones. {pull}13918[13918]
- Add ExpandEventListFromField config option in the kafka input. {pull}13965[13965]
- Add ELB fileset to AWS module. {pull}14020[14020]
- Add module for MISP (Malware Information Sharing Platform). {pull}13805[13805]

*Heartbeat*
- Add non-privileged icmp on linux and darwin(mac). {pull}13795[13795] {issue}11498[11498]

- Enable `add_observer_metadata` processor in default config. {pull}11394[11394]
- Record HTTP body metadata and optionally contents in `http.response.body.*` fields. {pull}13022[13022]
- Allow `hosts` to be used to configure http monitors {pull}13703[13703]

*Journalbeat*

*Metricbeat*

- Add AWS SQS metricset. {pull}10684[10684] {issue}10053[10053]
- Add AWS s3_request metricset. {pull}10949[10949] {issue}10055[10055]
- Add s3_daily_storage metricset. {pull}10940[10940] {issue}10055[10055]
- Add `coredns` metricbeat module. {pull}10585[10585]
- Add SSL support for Metricbeat HTTP server. {pull}11482[11482] {issue}11457[11457]
- The `elasticsearch.index` metricset (with `xpack.enabled: true`) now collects `refresh.external_total_time_in_millis` fields from Elasticsearch. {pull}11616[11616]
- Allow module configurations to have variants {pull}9118[9118]
- Add `timeseries.instance` field calculation. {pull}10293[10293]
- Added new disk states and raid level to the system/raid metricset. {pull}11613[11613]
- Added `path_name` and `start_name` to service metricset on windows module {issue}8364[8364] {pull}11877[11877]
- Add check on object name in the counter path if the instance name is missing {issue}6528[6528] {pull}11878[11878]
- Add AWS cloudwatch metricset. {pull}11798[11798] {issue}11734[11734]
- Add `regions` in aws module config to specify target regions for querying cloudwatch metrics. {issue}11932[11932] {pull}11956[11956]
- Keep `etcd` followers members from reporting `leader` metricset events {pull}12004[12004]
- Add overview dashboard to Consul module {pull}10665[10665]
- New fields were added in the mysql/status metricset. {pull}12227[12227]
- Add Kubernetes metricset `proxy`. {pull}12312[12312]
- Add Kubernetes proxy dashboard to Kubernetes module {pull}12734[12734]
- Always report Pod UID in the `pod` metricset. {pull}12345[12345]
- Add Vsphere Virtual Machine operating system to `os` field in Vsphere virtualmachine module. {pull}12391[12391]
- Add validation for elasticsearch and kibana modules' metricsets when xpack.enabled is set to true. {pull}12386[12386]
- Add CockroachDB module. {pull}12467[12467]
- Add support for metricbeat modules based on existing modules (a.k.a. light modules) {issue}12270[12270] {pull}12465[12465]
- Add a system/entropy metricset {pull}12450[12450]
- Add kubernetes metricset `controllermanager` {pull}12409[12409]
- Add Kubernetes controller manager dashboard to Kubernetes module {pull}12744[12744]
- Allow redis URL format in redis hosts config. {pull}12408[12408]
- Add tags into ec2 metricset. {issue}[12263]12263 {pull}12372[12372]
- Add metrics to kubernetes apiserver metricset. {pull}12922[12922]
- Add kubernetes metricset `scheduler` {pull}12521[12521]
- Add Kubernetes scheduler dashboard to Kubernetes module {pull}12749[12749]
- Add `beat` module. {pull}12181[12181] {pull}12615[12615]
- Collect tags for cloudwatch metricset in aws module. {issue}[12263]12263 {pull}12480[12480]
- Add AWS RDS metricset. {pull}11620[11620] {issue}10054[10054]
- Add Oracle Module {pull}11890[11890]
- Add Oracle Tablespaces Dashboard {pull}12736[12736]
- Collect client provided name for rabbitmq connection. {issue}12851[12851] {pull}12852[12852]
- Add support to load default aws config file to get credentials. {pull}12727[12727] {issue}12708[12708]
- Add statistic option into cloudwatch metricset. {issue}12370[12370] {pull}12840[12840]
- Add support for kubernetes cronjobs {pull}13001[13001]
- Add cgroup memory stats to docker/memory metricset {pull}12916[12916]
- Add AWS elb metricset. {pull}12952[12952] {issue}11701[11701]
- Add AWS ebs metricset. {pull}13167[13167] {issue}11699[11699]
- Add `metricset.period` field with the configured fetching period. {pull}13242[13242] {issue}12616[12616]
- Add rate metrics for ec2 metricset. {pull}13203[13203]
- Add refresh list of perf counters at every fetch {issue}13091[13091]
- Add Performance metricset to Oracle module {pull}12547[12547]
- Add proc/vmstat data to the system/memory metricset on linux {pull}13322[13322]
- Use DefaultMetaGeneratorConfig in MetadataEnrichers to initialize configurations {pull}13414[13414]
- Add module for statsd. {pull}13109[13109]
- Add support for NATS version 2. {pull}13601[13601]
- Add `docker.cpu.*.norm.pct` metrics for `cpu` metricset of Docker Metricbeat module. {pull}13695[13695]
- Add `instance` label by default when using Prometheus collector. {pull}13737[13737]
- Add azure module. {pull}13196[13196] {pull}13859[13859] {pull}13988[13988]
- Add Apache Tomcat module {pull}13491[13491]
- Add ECS `container.id` and `container.runtime` to kubernetes `state_container` metricset. {pull}13884[13884]
- Add `job` label by default when using Prometheus collector. {pull}13878[13878]
- Add `state_resourcequota` metricset for Kubernetes module. {pull}13693[13693]
- Add tags filter in ec2 metricset. {pull}13872[13872] {issue}13145[13145]
- Add cloud.account.id and cloud.account.name into events from aws module. {issue}13551[13551] {pull}13558[13558]
- Add `metrics_path` as known hint for autodiscovery {pull}13996[13996]
- Leverage KUBECONFIG when creating k8s client. {pull}13916[13916]
- Add ability to filter by tags for cloudwatch metricset. {pull}13758[13758] {issue}13145[13145]

*Packetbeat*

- Update DNS protocol plugin to produce events with ECS fields for DNS. {issue}13320[13320] {pull}13354[13354]

*Functionbeat*

- New options to configure roles and VPC. {pull}11779[11779]
- Export automation templates used to create functions. {pull}11923[11923]
- Configurable Amazon endpoint. {pull}12369[12369]
- Add timeout option to reference configuration. {pull}13351[13351]
- Configurable tags for Lambda functions. {pull}13352[13352]
- Add input for Cloudwatch logs through Kinesis. {pull}13317[13317]
- Enable Logstash output. {pull}13345[13345]
- Make `bulk_max_size` configurable in outputs. {pull}13493[13493]

*Winlogbeat*

- Add support for reading from .evtx files. {issue}4450[4450]
- Add support for event ID 4634 and 4647 to the Security module. {pull}12906[12906]
- Add `network.community_id` to Sysmon network events (event ID 3). {pull}13034[13034]
- Add `event.module` to Winlogbeat modules. {pull}13047[13047]
- Add `event.category: process` and `event.type: process_start/process_end` to Sysmon process events (event ID 1 and 5). {pull}13047[13047]
- Add support for event ID 4672 to the Security module. {pull}12975[12975]
- Add support for event ID 22 (DNS query) to the Sysmon module. {pull}12960[12960]
- Add certain winlog.event_data.* fields to the index template. {issue}13700[13700] {pull}13704[13704]
- Fill `event.provider`. {pull}13937[13937]
- Add support for user management events to the Security module. {pull}13530[13530]

==== Deprecated

*Affecting all Beats*

*Filebeat*

- `docker` input is deprecated in favour `container`. {pull}12162[12162]
- `postgresql.log.timestamp` field is deprecated in favour of `@timestamp`. {pull}12338[12338]

*Heartbeat*

*Journalbeat*

*Metricbeat*

- `kubernetes.container.id` field for `state_container` is deprecated in favour of ECS `container.id` and `container.runtime`. {pull}13884[13884]

*Packetbeat*

*Winlogbeat*

*Functionbeat*

==== Known Issue

*Journalbeat*
",12191,True,2816.9770393061212,median
"/***
*
*	Copyright (c) 1996-2002, Valve LLC. All rights reserved.
*	
*	This product contains software technology licensed from Id 
*	Software, Inc. (""Id Technology"").  Id Technology (c) 1996 Id Software, Inc. 
*	All Rights Reserved.
*
*   Use, distribution, and modification of this source code and/or resulting
*   object code is restricted to non-commercial enhancements to products from
*   Valve LLC.  All other use, distribution, or modification is prohibited
*   without written permission from Valve LLC.
*
****/
#include ""hud.h""
#include ""cl_util.h""
#include ""const.h""
#include ""entity_state.h""
#include ""cl_entity.h""
#include ""entity_types.h""
#include ""usercmd.h""
#include ""pm_defs.h""
#include ""pm_materials.h""

#include ""eventscripts.h""
#include ""ev_hldm.h""

#include ""r_efx.h""
#include ""event_api.h""
#include ""event_args.h""
#include ""in_defs.h""

#include <string.h>

#include ""r_studioint.h""
#include ""com_model.h""

extern engine_studio_api_t IEngineStudio;

static int tracerCount[ 32 ];

extern ""C"" char PM_FindTextureType( char *name );

void V_PunchAxis( int axis, float punch );
void VectorAngles( const float *forward, float *angles );

extern cvar_t *cl_lw;

extern ""C""
{

// HLDM
void EV_FireGlock1( struct event_args_s *args  );
void EV_FireGlock2( struct event_args_s *args  );
void EV_FireShotGunSingle( struct event_args_s *args  );
void EV_FireShotGunDouble( struct event_args_s *args  );
void EV_FireMP5( struct event_args_s *args  );
void EV_FireMP52( struct event_args_s *args  );
void EV_FirePython( struct event_args_s *args  );
void EV_FireGauss( struct event_args_s *args  );
void EV_SpinGauss( struct event_args_s *args  );
void EV_Crowbar( struct event_args_s *args  );
void EV_FireCrossbow( struct event_args_s *args  );
void EV_FireCrossbow2( struct event_args_s *args  );
void EV_FireRpg( struct event_args_s *args  );
void EV_EgonFire( struct event_args_s *args  );
void EV_EgonStop( struct event_args_s *args  );
void EV_HornetGunFire( struct event_args_s *args  );
void EV_TripmineFire( struct event_args_s *args  );
void EV_SnarkFire( struct event_args_s *args  );


void EV_TrainPitchAdjust( struct event_args_s *args );
}

#define VECTOR_CONE_1DEGREES Vector( 0.00873, 0.00873, 0.00873 )
#define VECTOR_CONE_2DEGREES Vector( 0.01745, 0.01745, 0.01745 )
#define VECTOR_CONE_3DEGREES Vector( 0.02618, 0.02618, 0.02618 )
#define VECTOR_CONE_4DEGREES Vector( 0.03490, 0.03490, 0.03490 )
#define VECTOR_CONE_5DEGREES Vector( 0.04362, 0.04362, 0.04362 )
#define VECTOR_CONE_6DEGREES Vector( 0.05234, 0.05234, 0.05234 )
#define VECTOR_CONE_7DEGREES Vector( 0.06105, 0.06105, 0.06105 )	
#define VECTOR_CONE_8DEGREES Vector( 0.06976, 0.06976, 0.06976 )
#define VECTOR_CONE_9DEGREES Vector( 0.07846, 0.07846, 0.07846 )
#define VECTOR_CONE_10DEGREES Vector( 0.08716, 0.08716, 0.08716 )
#define VECTOR_CONE_15DEGREES Vector( 0.13053, 0.13053, 0.13053 )
#define VECTOR_CONE_20DEGREES Vector( 0.17365, 0.17365, 0.17365 )

// play a strike sound based on the texture that was hit by the attack traceline.  VecSrc/VecEnd are the
// original traceline endpoints used by the attacker, iBulletType is the type of bullet that hit the texture.
// returns volume of strike instrument (crowbar) to play
float EV_HLDM_PlayTextureSound( int idx, pmtrace_t *ptr, float *vecSrc, float *vecEnd, int iBulletType )
{
	// hit the world, try to play sound based on texture material type
	char chTextureType = CHAR_TEX_CONCRETE;
	float fvol;
	float fvolbar;
	char *rgsz[4];
	int cnt;
	float fattn = ATTN_NORM;
	int entity;
	char *pTextureName;
	char texname[ 64 ];
	char szbuffer[ 64 ];

	entity = gEngfuncs.pEventAPI->EV_IndexFromTrace( ptr );

	// FIXME check if playtexture sounds movevar is set
	//

	chTextureType = 0;

	// Player
	if ( entity >= 1 && entity <= gEngfuncs.GetMaxClients() )
	{
		// hit body
		chTextureType = CHAR_TEX_FLESH;
	}
	else if ( entity == 0 )
	{
		// get texture from entity or world (world is ent(0))
		pTextureName = (char *)gEngfuncs.pEventAPI->EV_TraceTexture( ptr->ent, vecSrc, vecEnd );
		
		if ( pTextureName )
		{
			strcpy( texname, pTextureName );
			pTextureName = texname;

			// strip leading '-0' or '+0~' or '{' or '!'
			if (*pTextureName == '-' || *pTextureName == '+')
			{
				pTextureName += 2;
			}

			if (*pTextureName == '{' || *pTextureName == '!' || *pTextureName == '~' || *pTextureName == ' ')
			{
				pTextureName++;
			}
			
			// '}}'
			strcpy( szbuffer, pTextureName );
			szbuffer[ CBTEXTURENAMEMAX - 1 ] = 0;
				
			// get texture type
			chTextureType = PM_FindTextureType( szbuffer );	
		}
	}
	
	switch (chTextureType)
	{
	default:
	case CHAR_TEX_CONCRETE: fvol = 0.9;	fvolbar = 0.6;
		rgsz[0] = ""player/pl_step1.wav"";
		rgsz[1] = ""player/pl_step2.wav"";
		cnt = 2;
		break;
	case CHAR_TEX_METAL: fvol = 0.9; fvolbar = 0.3;
		rgsz[0] = ""player/pl_metal1.wav"";
		rgsz[1] = ""player/pl_metal2.wav"";
		cnt = 2;
		break;
	case CHAR_TEX_DIRT:	fvol = 0.9; fvolbar = 0.1;
		rgsz[0] = ""player/pl_dirt1.wav"";
		rgsz[1] = ""player/pl_dirt2.wav"";
		rgsz[2] = ""player/pl_dirt3.wav"";
		cnt = 3;
		break;
	case CHAR_TEX_VENT:	fvol = 0.5; fvolbar = 0.3;
		rgsz[0] = ""player/pl_duct1.wav"";
		rgsz[1] = ""player/pl_duct1.wav"";
		cnt = 2;
		break;
	case CHAR_TEX_GRATE: fvol = 0.9; fvolbar = 0.5;
		rgsz[0] = ""player/pl_grate1.wav"";
		rgsz[1] = ""player/pl_grate4.wav"";
		cnt = 2;
		break;
	case CHAR_TEX_TILE:	fvol = 0.8; fvolbar = 0.2;
		rgsz[0] = ""player/pl_tile1.wav"";
		rgsz[1] = ""player/pl_tile3.wav"";
		rgsz[2] = ""player/pl_tile2.wav"";
		rgsz[3] = ""player/pl_tile4.wav"";
		cnt = 4;
		break;
	case CHAR_TEX_SLOSH: fvol = 0.9; fvolbar = 0.0;
		rgsz[0] = ""player/pl_slosh1.wav"";
		rgsz[1] = ""player/pl_slosh3.wav"";
		rgsz[2] = ""player/pl_slosh2.wav"";
		rgsz[3] = ""player/pl_slosh4.wav"";
		cnt = 4;
		break;
	case CHAR_TEX_WOOD: fvol = 0.9; fvolbar = 0.2;
		rgsz[0] = ""debris/wood1.wav"";
		rgsz[1] = ""debris/wood2.wav"";
		rgsz[2] = ""debris/wood3.wav"";
		cnt = 3;
		break;
	case CHAR_TEX_GLASS:
	case CHAR_TEX_COMPUTER:
		fvol = 0.8; fvolbar = 0.2;
		rgsz[0] = ""debris/glass1.wav"";
		rgsz[1] = ""debris/glass2.wav"";
		rgsz[2] = ""debris/glass3.wav"";
		cnt = 3;
		break;
	case CHAR_TEX_FLESH:
		if (iBulletType == BULLET_PLAYER_CROWBAR)
			return 0.0; // crowbar already makes this sound
		fvol = 1.0;	fvolbar = 0.2;
		rgsz[0] = ""weapons/bullet_hit1.wav"";
		rgsz[1] = ""weapons/bullet_hit2.wav"";
		fattn = 1.0;
		cnt = 2;
		break;
	}

	// play material hit sound
	gEngfuncs.pEventAPI->EV_PlaySound( 0, ptr->endpos, CHAN_STATIC, rgsz[gEngfuncs.pfnRandomLong(0,cnt-1)], fvol, fattn, 0, 96 + gEngfuncs.pfnRandomLong(0,0xf) );
	return fvolbar;
}

char *EV_HLDM_DamageDecal( physent_t *pe )
{
	static char decalname[ 32 ];
	int idx;

	if ( pe->classnumber == 1 )
	{
		idx = gEngfuncs.pfnRandomLong( 0, 2 );
		sprintf( decalname, ""{break%i"", idx + 1 );
	}
	else if ( pe->rendermode != kRenderNormal )
	{
		sprintf( decalname, ""{bproof1"" );
	}
	else
	{
		idx = gEngfuncs.pfnRandomLong( 0, 4 );
		sprintf( decalname, ""{shot%i"", idx + 1 );
	}
	return decalname;
}

void EV_HLDM_GunshotDecalTrace( pmtrace_t *pTrace, char *decalName )
{
	int iRand;
	physent_t *pe;

	gEngfuncs.pEfxAPI->R_BulletImpactParticles( pTrace->endpos );

	iRand = gEngfuncs.pfnRandomLong(0,0x7FFF);
	if ( iRand < (0x7fff/2) )// not every bullet makes a sound.
	{
		switch( iRand % 5)
		{
		case 0:	gEngfuncs.pEventAPI->EV_PlaySound( -1, pTrace->endpos, 0, ""weapons/ric1.wav"", 1.0, ATTN_NORM, 0, PITCH_NORM ); break;
		case 1:	gEngfuncs.pEventAPI->EV_PlaySound( -1, pTrace->endpos, 0, ""weapons/ric2.wav"", 1.0, ATTN_NORM, 0, PITCH_NORM ); break;
		case 2:	gEngfuncs.pEventAPI->EV_PlaySound( -1, pTrace->endpos, 0, ""weapons/ric3.wav"", 1.0, ATTN_NORM, 0, PITCH_NORM ); break;
		case 3:	gEngfuncs.pEventAPI->EV_PlaySound( -1, pTrace->endpos, 0, ""weapons/ric4.wav"", 1.0, ATTN_NORM, 0, PITCH_NORM ); break;
		case 4:	gEngfuncs.pEventAPI->EV_PlaySound( -1, pTrace->endpos, 0, ""weapons/ric5.wav"", 1.0, ATTN_NORM, 0, PITCH_NORM ); break;
		}
	}

	pe = gEngfuncs.pEventAPI->EV_GetPhysent( pTrace->ent );

	// Only decal brush models such as the world etc.
	if (  decalName && decalName[0] && pe && ( pe->solid == SOLID_BSP || pe->movetype == MOVETYPE_PUSHSTEP ) )
	{
		if ( CVAR_GET_FLOAT( ""r_decals"" ) )
		{
			gEngfuncs.pEfxAPI->R_DecalShoot( 
				gEngfuncs.pEfxAPI->Draw_DecalIndex( gEngfuncs.pEfxAPI->Draw_DecalIndexFromName( decalName ) ), 
				gEngfuncs.pEventAPI->EV_IndexFromTrace( pTrace ), 0, pTrace->endpos, 0 );
		}
	}
}

void EV_HLDM_DecalGunshot( pmtrace_t *pTrace, int iBulletType )
{
	physent_t *pe;

	pe = gEngfuncs.pEventAPI->EV_GetPhysent( pTrace->ent );

	if ( pe && pe->solid == SOLID_BSP )
	{
		switch( iBulletType )
		{
		case BULLET_PLAYER_9MM:
		case BULLET_MONSTER_9MM:
		case BULLET_PLAYER_MP5:
		case BULLET_MONSTER_MP5:
		case BULLET_PLAYER_BUCKSHOT:
		case BULLET_PLAYER_357:
		default:
			// smoke and decal
			EV_HLDM_GunshotDecalTrace( pTrace, EV_HLDM_DamageDecal( pe ) );
			break;
		}
	}
}

int EV_HLDM_CheckTracer( int idx, float *vecSrc, float *end, float *forward, float *right, int iBulletType, int iTracerFreq, int *tracerCount )
{
	int tracer = 0;
	int i;
	qboolean player = idx >= 1 && idx <= gEngfuncs.GetMaxClients() ? true : false;

	if ( iTracerFreq != 0 && ( (*tracerCount)++ % iTracerFreq) == 0 )
	{
		vec3_t vecTracerSrc;

		if ( player )
		{
			vec3_t offset( 0, 0, -4 );

			// adjust tracer position for player
			for ( i = 0; i < 3; i++ )
			{
				vecTracerSrc[ i ] = vecSrc[ i ] + offset[ i ] + right[ i ] * 2 + forward[ i ] * 16;
			}
		}
		else
		{
			VectorCopy( vecSrc, vecTracerSrc );
		}
		
		if ( iTracerFreq != 1 )		// guns that always trace also always decal
			tracer = 1;

		switch( iBulletType )
		{
		case BULLET_PLAYER_MP5:
		case BULLET_MONSTER_MP5:
		case BULLET_MONSTER_9MM:
		case BULLET_MONSTER_12MM:
		default:
			EV_CreateTracer( vecTracerSrc, end );
			break;
		}
	}

	return tracer;
}


/*
================
FireBullets

Go to the trouble of combining multiple pellets into a single damage call.
================
*/
void EV_HLDM_FireBullets( int idx, float *forward, float *right, float *up, int cShots, float *vecSrc, float *vecDirShooting, float flDistance, int iBulletType, int iTracerFreq, int *tracerCount, float flSpreadX, float flSpreadY )
{
	int i;
	pmtrace_t tr;
	int iShot;
	int tracer;
	
	for ( iShot = 1; iShot <= cShots; iShot++ )	
	{
		vec3_t vecDir, vecEnd;
			
		float x, y, z;
		//We randomize for the Shotgun.
		if ( iBulletType == BULLET_PLAYER_BUCKSHOT )
		{
			do {
				x = gEngfuncs.pfnRandomFloat(-0.5,0.5) + gEngfuncs.pfnRandomFloat(-0.5,0.5);
				y = gEngfuncs.pfnRandomFloat(-0.5,0.5) + gEngfuncs.pfnRandomFloat(-0.5,0.5);
				z = x*x+y*y;
			} while (z > 1);

			for ( i = 0 ; i < 3; i++ )
			{
				vecDir[i] = vecDirShooting[i] + x * flSpreadX * right[ i ] + y * flSpreadY * up [ i ];
				vecEnd[i] = vecSrc[ i ] + flDistance * vecDir[ i ];
			}
		}//But other guns already have their spread randomized in the synched spread.
		else
		{

			for ( i = 0 ; i < 3; i++ )
			{
				vecDir[i] = vecDirShooting[i] + flSpreadX * right[ i ] + flSpreadY * up [ i ];
				vecEnd[i] = vecSrc[ i ] + flDistance * vecDir[ i ];
			}
		}

		gEngfuncs.pEventAPI->EV_SetUpPlayerPrediction( false, true );
	
		// Store off the old count
		gEngfuncs.pEventAPI->EV_PushPMStates();
	
		// Now add in all of the players.
		gEngfuncs.pEventAPI->EV_SetSolidPlayers ( idx - 1 );	

		gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
		gEngfuncs.pEventAPI->EV_PlayerTrace( vecSrc, vecEnd, PM_STUDIO_BOX, -1, &tr );

		tracer = EV_HLDM_CheckTracer( idx, vecSrc, tr.endpos, forward, right, iBulletType, iTracerFreq, tracerCount );

		// do damage, paint decals
		if ( tr.fraction != 1.0 )
		{
			switch(iBulletType)
			{
			default:
			case BULLET_PLAYER_9MM:		
				
				EV_HLDM_PlayTextureSound( idx, &tr, vecSrc, vecEnd, iBulletType );
				EV_HLDM_DecalGunshot( &tr, iBulletType );
			
					break;
			case BULLET_PLAYER_MP5:		
				
				if ( !tracer )
				{
					EV_HLDM_PlayTextureSound( idx, &tr, vecSrc, vecEnd, iBulletType );
					EV_HLDM_DecalGunshot( &tr, iBulletType );
				}
				break;
			case BULLET_PLAYER_BUCKSHOT:
				
				EV_HLDM_DecalGunshot( &tr, iBulletType );
			
				break;
			case BULLET_PLAYER_357:
				
				EV_HLDM_PlayTextureSound( idx, &tr, vecSrc, vecEnd, iBulletType );
				EV_HLDM_DecalGunshot( &tr, iBulletType );
				
				break;

			}
		}

		gEngfuncs.pEventAPI->EV_PopPMStates();
	}
}

//======================
//	    GLOCK START
//======================
void EV_FireGlock1( event_args_t *args )
{
	int idx;
	vec3_t origin;
	vec3_t angles;
	vec3_t velocity;
	int empty;

	vec3_t ShellVelocity;
	vec3_t ShellOrigin;
	int shell;
	vec3_t vecSrc, vecAiming;
	vec3_t up, right, forward;
	
	idx = args->entindex;
	VectorCopy( args->origin, origin );
	VectorCopy( args->angles, angles );
	VectorCopy( args->velocity, velocity );

	empty = args->bparam1;
	AngleVectors( angles, forward, right, up );

	shell = gEngfuncs.pEventAPI->EV_FindModelIndex (""models/shell.mdl"");// brass shell

	if ( EV_IsLocal( idx ) )
	{
		EV_MuzzleFlash();
		gEngfuncs.pEventAPI->EV_WeaponAnimation( empty ? GLOCK_SHOOT_EMPTY : GLOCK_SHOOT, 2 );

		V_PunchAxis( 0, -2.0 );
	}

	EV_GetDefaultShellInfo( args, origin, velocity, ShellVelocity, ShellOrigin, forward, right, up, 20, -12, 4 );

	EV_EjectBrass ( ShellOrigin, ShellVelocity, angles[ YAW ], shell, TE_BOUNCE_SHELL ); 

	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""weapons/pl_gun3.wav"", gEngfuncs.pfnRandomFloat(0.92, 1.0), ATTN_NORM, 0, 98 + gEngfuncs.pfnRandomLong( 0, 3 ) );

	EV_GetGunPosition( args, vecSrc, origin );
	
	VectorCopy( forward, vecAiming );

	EV_HLDM_FireBullets( idx, forward, right, up, 1, vecSrc, vecAiming, 8192, BULLET_PLAYER_9MM, 0, 0, args->fparam1, args->fparam2 );
}

void EV_FireGlock2( event_args_t *args )
{
	int idx;
	vec3_t origin;
	vec3_t angles;
	vec3_t velocity;
	
	vec3_t ShellVelocity;
	vec3_t ShellOrigin;
	int shell;
	vec3_t vecSrc, vecAiming;
	vec3_t vecSpread;
	vec3_t up, right, forward;

	idx = args->entindex;
	VectorCopy( args->origin, origin );
	VectorCopy( args->angles, angles );
	VectorCopy( args->velocity, velocity );

	AngleVectors( angles, forward, right, up );

	shell = gEngfuncs.pEventAPI->EV_FindModelIndex (""models/shell.mdl"");// brass shell

	if ( EV_IsLocal( idx ) )
	{
		// Add muzzle flash to current weapon model
		EV_MuzzleFlash();
		gEngfuncs.pEventAPI->EV_WeaponAnimation( GLOCK_SHOOT, 2 );

		V_PunchAxis( 0, -2.0 );
	}

	EV_GetDefaultShellInfo( args, origin, velocity, ShellVelocity, ShellOrigin, forward, right, up, 20, -12, 4 );

	EV_EjectBrass ( ShellOrigin, ShellVelocity, angles[ YAW ], shell, TE_BOUNCE_SHELL ); 

	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""weapons/pl_gun3.wav"", gEngfuncs.pfnRandomFloat(0.92, 1.0), ATTN_NORM, 0, 98 + gEngfuncs.pfnRandomLong( 0, 3 ) );

	EV_GetGunPosition( args, vecSrc, origin );
	
	VectorCopy( forward, vecAiming );

	EV_HLDM_FireBullets( idx, forward, right, up, 1, vecSrc, vecAiming, 8192, BULLET_PLAYER_9MM, 0, &tracerCount[idx-1], args->fparam1, args->fparam2 );
	
}
//======================
//	   GLOCK END
//======================

//======================
//	  SHOTGUN START
//======================
void EV_FireShotGunDouble( event_args_t *args )
{
	int idx;
	vec3_t origin;
	vec3_t angles;
	vec3_t velocity;

	int j;
	vec3_t ShellVelocity;
	vec3_t ShellOrigin;
	int shell;
	vec3_t vecSrc, vecAiming;
	vec3_t vecSpread;
	vec3_t up, right, forward;
	float flSpread = 0.01;

	idx = args->entindex;
	VectorCopy( args->origin, origin );
	VectorCopy( args->angles, angles );
	VectorCopy( args->velocity, velocity );

	AngleVectors( angles, forward, right, up );

	shell = gEngfuncs.pEventAPI->EV_FindModelIndex (""models/shotgunshell.mdl"");// brass shell

	if ( EV_IsLocal( idx ) )
	{
		// Add muzzle flash to current weapon model
		EV_MuzzleFlash();
		gEngfuncs.pEventAPI->EV_WeaponAnimation( SHOTGUN_FIRE2, 2 );
		V_PunchAxis( 0, -10.0 );
	}

	for ( j = 0; j < 2; j++ )
	{
		EV_GetDefaultShellInfo( args, origin, velocity, ShellVelocity, ShellOrigin, forward, right, up, 32, -12, 6 );

		EV_EjectBrass ( ShellOrigin, ShellVelocity, angles[ YAW ], shell, TE_BOUNCE_SHOTSHELL ); 
	}

	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""weapons/dbarrel1.wav"", gEngfuncs.pfnRandomFloat(0.98, 1.0), ATTN_NORM, 0, 85 + gEngfuncs.pfnRandomLong( 0, 0x1f ) );

	EV_GetGunPosition( args, vecSrc, origin );
	VectorCopy( forward, vecAiming );

	if ( gEngfuncs.GetMaxClients() > 1 )
	{
		EV_HLDM_FireBullets( idx, forward, right, up, 8, vecSrc, vecAiming, 2048, BULLET_PLAYER_BUCKSHOT, 0, &tracerCount[idx-1], 0.17365, 0.04362 );
	}
	else
	{
		EV_HLDM_FireBullets( idx, forward, right, up, 12, vecSrc, vecAiming, 2048, BULLET_PLAYER_BUCKSHOT, 0, &tracerCount[idx-1], 0.08716, 0.08716 );
	}
}

void EV_FireShotGunSingle( event_args_t *args )
{
	int idx;
	vec3_t origin;
	vec3_t angles;
	vec3_t velocity;
	
	vec3_t ShellVelocity;
	vec3_t ShellOrigin;
	int shell;
	vec3_t vecSrc, vecAiming;
	vec3_t vecSpread;
	vec3_t up, right, forward;
	float flSpread = 0.01;

	idx = args->entindex;
	VectorCopy( args->origin, origin );
	VectorCopy( args->angles, angles );
	VectorCopy( args->velocity, velocity );

	AngleVectors( angles, forward, right, up );

	shell = gEngfuncs.pEventAPI->EV_FindModelIndex (""models/shotgunshell.mdl"");// brass shell

	if ( EV_IsLocal( idx ) )
	{
		// Add muzzle flash to current weapon model
		EV_MuzzleFlash();
		gEngfuncs.pEventAPI->EV_WeaponAnimation( SHOTGUN_FIRE, 2 );

		V_PunchAxis( 0, -5.0 );
	}

	EV_GetDefaultShellInfo( args, origin, velocity, ShellVelocity, ShellOrigin, forward, right, up, 32, -12, 6 );

	EV_EjectBrass ( ShellOrigin, ShellVelocity, angles[ YAW ], shell, TE_BOUNCE_SHOTSHELL ); 

	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""weapons/sbarrel1.wav"", gEngfuncs.pfnRandomFloat(0.95, 1.0), ATTN_NORM, 0, 93 + gEngfuncs.pfnRandomLong( 0, 0x1f ) );

	EV_GetGunPosition( args, vecSrc, origin );
	VectorCopy( forward, vecAiming );

	if ( gEngfuncs.GetMaxClients() > 1 )
	{
		EV_HLDM_FireBullets( idx, forward, right, up, 4, vecSrc, vecAiming, 2048, BULLET_PLAYER_BUCKSHOT, 0, &tracerCount[idx-1], 0.08716, 0.04362 );
	}
	else
	{
		EV_HLDM_FireBullets( idx, forward, right, up, 6, vecSrc, vecAiming, 2048, BULLET_PLAYER_BUCKSHOT, 0, &tracerCount[idx-1], 0.08716, 0.08716 );
	}
}
//======================
//	   SHOTGUN END
//======================

//======================
//	    MP5 START
//======================
void EV_FireMP5( event_args_t *args )
{
	int idx;
	vec3_t origin;
	vec3_t angles;
	vec3_t velocity;

	vec3_t ShellVelocity;
	vec3_t ShellOrigin;
	int shell;
	vec3_t vecSrc, vecAiming;
	vec3_t up, right, forward;
	float flSpread = 0.01;

	idx = args->entindex;
	VectorCopy( args->origin, origin );
	VectorCopy( args->angles, angles );
	VectorCopy( args->velocity, velocity );

	AngleVectors( angles, forward, right, up );

	shell = gEngfuncs.pEventAPI->EV_FindModelIndex (""models/shell.mdl"");// brass shell
	
	if ( EV_IsLocal( idx ) )
	{
		// Add muzzle flash to current weapon model
		EV_MuzzleFlash();
		gEngfuncs.pEventAPI->EV_WeaponAnimation( MP5_FIRE1 + gEngfuncs.pfnRandomLong(0,2), 2 );

		V_PunchAxis( 0, gEngfuncs.pfnRandomFloat( -2, 2 ) );
	}

	EV_GetDefaultShellInfo( args, origin, velocity, ShellVelocity, ShellOrigin, forward, right, up, 20, -12, 4 );

	EV_EjectBrass ( ShellOrigin, ShellVelocity, angles[ YAW ], shell, TE_BOUNCE_SHELL ); 

	switch( gEngfuncs.pfnRandomLong( 0, 1 ) )
	{
	case 0:
		gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""weapons/hks1.wav"", 1, ATTN_NORM, 0, 94 + gEngfuncs.pfnRandomLong( 0, 0xf ) );
		break;
	case 1:
		gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""weapons/hks2.wav"", 1, ATTN_NORM, 0, 94 + gEngfuncs.pfnRandomLong( 0, 0xf ) );
		break;
	}

	EV_GetGunPosition( args, vecSrc, origin );
	VectorCopy( forward, vecAiming );

	if ( gEngfuncs.GetMaxClients() > 1 )
	{
		EV_HLDM_FireBullets( idx, forward, right, up, 1, vecSrc, vecAiming, 8192, BULLET_PLAYER_MP5, 2, &tracerCount[idx-1], args->fparam1, args->fparam2 );
	}
	else
	{
		EV_HLDM_FireBullets( idx, forward, right, up, 1, vecSrc, vecAiming, 8192, BULLET_PLAYER_MP5, 2, &tracerCount[idx-1], args->fparam1, args->fparam2 );
	}
}

// We only predict the animation and sound
// The grenade is still launched from the server.
void EV_FireMP52( event_args_t *args )
{
	int idx;
	vec3_t origin;
	
	idx = args->entindex;
	VectorCopy( args->origin, origin );

	if ( EV_IsLocal( idx ) )
	{
		gEngfuncs.pEventAPI->EV_WeaponAnimation( MP5_LAUNCH, 2 );
		V_PunchAxis( 0, -10 );
	}
	
	switch( gEngfuncs.pfnRandomLong( 0, 1 ) )
	{
	case 0:
		gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""weapons/glauncher.wav"", 1, ATTN_NORM, 0, 94 + gEngfuncs.pfnRandomLong( 0, 0xf ) );
		break;
	case 1:
		gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""weapons/glauncher2.wav"", 1, ATTN_NORM, 0, 94 + gEngfuncs.pfnRandomLong( 0, 0xf ) );
		break;
	}
}
//======================
//		 MP5 END
//======================

//======================
//	   PHYTON START 
//	     ( .357 )
//======================
void EV_FirePython( event_args_t *args )
{
	int idx;
	vec3_t origin;
	vec3_t angles;
	vec3_t velocity;

	vec3_t vecSrc, vecAiming;
	vec3_t up, right, forward;
	float flSpread = 0.01;

	idx = args->entindex;
	VectorCopy( args->origin, origin );
	VectorCopy( args->angles, angles );
	VectorCopy( args->velocity, velocity );

	AngleVectors( angles, forward, right, up );

	if ( EV_IsLocal( idx ) )
	{
		// Python uses different body in multiplayer versus single player
		int multiplayer = gEngfuncs.GetMaxClients() == 1 ? 0 : 1;

		// Add muzzle flash to current weapon model
		EV_MuzzleFlash();
		gEngfuncs.pEventAPI->EV_WeaponAnimation( PYTHON_FIRE1, multiplayer ? 1 : 0 );

		V_PunchAxis( 0, -10.0 );
	}

	switch( gEngfuncs.pfnRandomLong( 0, 1 ) )
	{
	case 0:
		gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""weapons/357_shot1.wav"", gEngfuncs.pfnRandomFloat(0.8, 0.9), ATTN_NORM, 0, PITCH_NORM );
		break;
	case 1:
		gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""weapons/357_shot2.wav"", gEngfuncs.pfnRandomFloat(0.8, 0.9), ATTN_NORM, 0, PITCH_NORM );
		break;
	}

	EV_GetGunPosition( args, vecSrc, origin );
	
	VectorCopy( forward, vecAiming );

	EV_HLDM_FireBullets( idx, forward, right, up, 1, vecSrc, vecAiming, 8192, BULLET_PLAYER_357, 0, 0, args->fparam1, args->fparam2 );
}
//======================
//	    PHYTON END 
//	     ( .357 )
//======================

//======================
//	   GAUSS START 
//======================
#define SND_CHANGE_PITCH	(1<<7)		// duplicated in protocol.h change sound pitch

void EV_SpinGauss( event_args_t *args )
{
	int idx;
	vec3_t origin;
	vec3_t angles;
	vec3_t velocity;
	int iSoundState = 0;

	int pitch;

	idx = args->entindex;
	VectorCopy( args->origin, origin );
	VectorCopy( args->angles, angles );
	VectorCopy( args->velocity, velocity );

	pitch = args->iparam1;

	iSoundState = args->bparam1 ? SND_CHANGE_PITCH : 0;

	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""ambience/pulsemachine.wav"", 1.0, ATTN_NORM, iSoundState, pitch );
}

/*
==============================
EV_StopPreviousGauss

==============================
*/
void EV_StopPreviousGauss( int idx )
{
	// Make sure we don't have a gauss spin event in the queue for this guy
	gEngfuncs.pEventAPI->EV_KillEvents( idx, ""events/gaussspin.sc"" );
	gEngfuncs.pEventAPI->EV_StopSound( idx, CHAN_WEAPON, ""ambience/pulsemachine.wav"" );
}

extern float g_flApplyVel;

void EV_FireGauss( event_args_t *args )
{
	int idx;
	vec3_t origin;
	vec3_t angles;
	vec3_t velocity;
	float flDamage = args->fparam1;
	int primaryfire = args->bparam1;

	int m_fPrimaryFire = args->bparam1;
	int m_iWeaponVolume = GAUSS_PRIMARY_FIRE_VOLUME;
	vec3_t vecSrc;
	vec3_t vecDest;
	edict_t		*pentIgnore;
	pmtrace_t tr, beam_tr;
	float flMaxFrac = 1.0;
	int	nTotal = 0;
	int fHasPunched = 0;
	int fFirstBeam = 1;
	int	nMaxHits = 10;
	physent_t *pEntity;
	int m_iBeam, m_iGlow, m_iBalls;
	vec3_t up, right, forward;

	idx = args->entindex;
	VectorCopy( args->origin, origin );
	VectorCopy( args->angles, angles );
	VectorCopy( args->velocity, velocity );

	if ( args->bparam2 )
	{
		EV_StopPreviousGauss( idx );
		return;
	}

//	Con_Printf( ""Firing gauss with %f\\n"", flDamage );
	EV_GetGunPosition( args, vecSrc, origin );

	m_iBeam = gEngfuncs.pEventAPI->EV_FindModelIndex( ""sprites/smoke.spr"" );
	m_iBalls = m_iGlow = gEngfuncs.pEventAPI->EV_FindModelIndex( ""sprites/hotglow.spr"" );
	
	AngleVectors( angles, forward, right, up );

	VectorMA( vecSrc, 8192, forward, vecDest );

	if ( EV_IsLocal( idx ) )
	{
		V_PunchAxis( 0, -2.0 );
		gEngfuncs.pEventAPI->EV_WeaponAnimation( GAUSS_FIRE2, 2 );

		if ( m_fPrimaryFire == false )
			 g_flApplyVel = flDamage;	
			 
	}

	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""weapons/gauss2.wav"", 0.5 + flDamage * (1.0 / 400.0), ATTN_NORM, 0, 85 + gEngfuncs.pfnRandomLong( 0, 0x1f ) );

	while (flDamage > 10 && nMaxHits > 0)
	{
		nMaxHits--;

		gEngfuncs.pEventAPI->EV_SetUpPlayerPrediction( false, true );
		
		// Store off the old count
		gEngfuncs.pEventAPI->EV_PushPMStates();
	
		// Now add in all of the players.
		gEngfuncs.pEventAPI->EV_SetSolidPlayers ( idx - 1 );	

		gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
		gEngfuncs.pEventAPI->EV_PlayerTrace( vecSrc, vecDest, PM_STUDIO_BOX, -1, &tr );

		gEngfuncs.pEventAPI->EV_PopPMStates();

		if ( tr.allsolid )
			break;

		if (fFirstBeam)
		{
			if ( EV_IsLocal( idx ) )
			{
				// Add muzzle flash to current weapon model
				EV_MuzzleFlash();
			}
			fFirstBeam = 0;

			gEngfuncs.pEfxAPI->R_BeamEntPoint( 
				idx | 0x1000,
				tr.endpos,
				m_iBeam,
				0.1,
				m_fPrimaryFire ? 1.0 : 2.5,
				0.0,
				m_fPrimaryFire ? 128.0 : flDamage,
				0,
				0,
				0,
				m_fPrimaryFire ? 255 : 255,
				m_fPrimaryFire ? 128 : 255,
				m_fPrimaryFire ? 0 : 255
			);
		}
		else
		{
			gEngfuncs.pEfxAPI->R_BeamPoints( vecSrc,
				tr.endpos,
				m_iBeam,
				0.1,
				m_fPrimaryFire ? 1.0 : 2.5,
				0.0,
				m_fPrimaryFire ? 128.0 : flDamage,
				0,
				0,
				0,
				m_fPrimaryFire ? 255 : 255,
				m_fPrimaryFire ? 128 : 255,
				m_fPrimaryFire ? 0 : 255
			);
		}

		pEntity = gEngfuncs.pEventAPI->EV_GetPhysent( tr.ent );
		if ( pEntity == NULL )
			break;

		if ( pEntity->solid == SOLID_BSP )
		{
			float n;

			pentIgnore = NULL;

			n = -DotProduct( tr.plane.normal, forward );

			if (n < 0.5) // 60 degrees	
			{
				// ALERT( at_console, ""reflect %f\\n"", n );
				// reflect
				vec3_t r;
			
				VectorMA( forward, 2.0 * n, tr.plane.normal, r );

				flMaxFrac = flMaxFrac - tr.fraction;
				
				VectorCopy( r, forward );

				VectorMA( tr.endpos, 8.0, forward, vecSrc );
				VectorMA( vecSrc, 8192.0, forward, vecDest );

				gEngfuncs.pEfxAPI->R_TempSprite( tr.endpos, vec3_origin, 0.2, m_iGlow, kRenderGlow, kRenderFxNoDissipation, flDamage * n / 255.0, flDamage * n * 0.5 * 0.1, FTENT_FADEOUT );

				vec3_t fwd;
				VectorAdd( tr.endpos, tr.plane.normal, fwd );

				gEngfuncs.pEfxAPI->R_Sprite_Trail( TE_SPRITETRAIL, tr.endpos, fwd, m_iBalls, 3, 0.1, gEngfuncs.pfnRandomFloat( 10, 20 ) / 100.0, 100,
									255, 100 );

				// lose energy
				if ( n == 0 )
				{
					n = 0.1;
				}
				
				flDamage = flDamage * (1 - n);

			}
			else
			{
				// tunnel
				EV_HLDM_DecalGunshot( &tr, BULLET_MONSTER_12MM );

				gEngfuncs.pEfxAPI->R_TempSprite( tr.endpos, vec3_origin, 1.0, m_iGlow, kRenderGlow, kRenderFxNoDissipation, flDamage / 255.0, 6.0, FTENT_FADEOUT );

				// limit it to one hole punch
				if (fHasPunched)
				{
					break;
				}
				fHasPunched = 1;
				
				// try punching through wall if secondary attack (primary is incapable of breaking through)
				if ( !m_fPrimaryFire )
				{
					vec3_t start;

					VectorMA( tr.endpos, 8.0, forward, start );

					// Store off the old count
					gEngfuncs.pEventAPI->EV_PushPMStates();
						
					// Now add in all of the players.
					gEngfuncs.pEventAPI->EV_SetSolidPlayers ( idx - 1 );

					gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
					gEngfuncs.pEventAPI->EV_PlayerTrace( start, vecDest, PM_STUDIO_BOX, -1, &beam_tr );

					if ( !beam_tr.allsolid )
					{
						vec3_t delta;
						float n;

						// trace backwards to find exit point

						gEngfuncs.pEventAPI->EV_PlayerTrace( beam_tr.endpos, tr.endpos, PM_STUDIO_BOX, -1, &beam_tr );

						VectorSubtract( beam_tr.endpos, tr.endpos, delta );
						
						n = Length( delta );

						if (n < flDamage)
						{
							if (n == 0)
								n = 1;
							flDamage -= n;

							// absorption balls
							{
								vec3_t fwd;
								VectorSubtract( tr.endpos, forward, fwd );
								gEngfuncs.pEfxAPI->R_Sprite_Trail( TE_SPRITETRAIL, tr.endpos, fwd, m_iBalls, 3, 0.1, gEngfuncs.pfnRandomFloat( 10, 20 ) / 100.0, 100,
									255, 100 );
							}

	//////////////////////////////////// WHAT TO DO HERE
							// CSoundEnt::InsertSound ( bits_SOUND_COMBAT, pev->origin, NORMAL_EXPLOSION_VOLUME, 3.0 );

							EV_HLDM_DecalGunshot( &beam_tr, BULLET_MONSTER_12MM );
							
							gEngfuncs.pEfxAPI->R_TempSprite( beam_tr.endpos, vec3_origin, 0.1, m_iGlow, kRenderGlow, kRenderFxNoDissipation, flDamage / 255.0, 6.0, FTENT_FADEOUT );
			
							// balls
							{
								vec3_t fwd;
								VectorSubtract( beam_tr.endpos, forward, fwd );
								gEngfuncs.pEfxAPI->R_Sprite_Trail( TE_SPRITETRAIL, beam_tr.endpos, fwd, m_iBalls, (int)(flDamage * 0.3), 0.1, gEngfuncs.pfnRandomFloat( 10, 20 ) / 100.0, 200,
									255, 40 );
							}
							
							VectorAdd( beam_tr.endpos, forward, vecSrc );
						}
					}
					else
					{
						flDamage = 0;
					}

					gEngfuncs.pEventAPI->EV_PopPMStates();
				}
				else
				{
					if ( m_fPrimaryFire )
					{
						// slug doesn't punch through ever with primary 
						// fire, so leave a little glowy bit and make some balls
						gEngfuncs.pEfxAPI->R_TempSprite( tr.endpos, vec3_origin, 0.2, m_iGlow, kRenderGlow, kRenderFxNoDissipation, 200.0 / 255.0, 0.3, FTENT_FADEOUT );
			
						{
							vec3_t fwd;
							VectorAdd( tr.endpos, tr.plane.normal, fwd );
							gEngfuncs.pEfxAPI->R_Sprite_Trail( TE_SPRITETRAIL, tr.endpos, fwd, m_iBalls, 8, 0.6, gEngfuncs.pfnRandomFloat( 10, 20 ) / 100.0, 100,
								255, 200 );
						}
					}

					flDamage = 0;
				}
			}
		}
		else
		{
			VectorAdd( tr.endpos, forward, vecSrc );
		}
	}
}
//======================
//	   GAUSS END 
//======================

//======================
//	   CROWBAR START
//======================

enum crowbar_e {
	CROWBAR_IDLE = 0,
	CROWBAR_DRAW,
	CROWBAR_HOLSTER,
	CROWBAR_ATTACK1HIT,
	CROWBAR_ATTACK1MISS,
	CROWBAR_ATTACK2MISS,
	CROWBAR_ATTACK2HIT,
	CROWBAR_ATTACK3MISS,
	CROWBAR_ATTACK3HIT
};

int g_iSwing;

//Only predict the miss sounds, hit sounds are still played 
//server side, so players don't get the wrong idea.
void EV_Crowbar( event_args_t *args )
{
	int idx;
	vec3_t origin;
	vec3_t angles;
	vec3_t velocity;

	idx = args->entindex;
	VectorCopy( args->origin, origin );
	
	//Play Swing sound
	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""weapons/cbar_miss1.wav"", 1, ATTN_NORM, 0, PITCH_NORM); 

	if ( EV_IsLocal( idx ) )
	{
		gEngfuncs.pEventAPI->EV_WeaponAnimation( CROWBAR_ATTACK1MISS, 1 );

		switch( (g_iSwing++) % 3 )
		{
			case 0:
				gEngfuncs.pEventAPI->EV_WeaponAnimation ( CROWBAR_ATTACK1MISS, 1 ); break;
			case 1:
				gEngfuncs.pEventAPI->EV_WeaponAnimation ( CROWBAR_ATTACK2MISS, 1 ); break;
			case 2:
				gEngfuncs.pEventAPI->EV_WeaponAnimation ( CROWBAR_ATTACK3MISS, 1 ); break;
		}
	}
}
//======================
//	   CROWBAR END 
//======================

//======================
//	  CROSSBOW START
//======================
enum crossbow_e {
	CROSSBOW_IDLE1 = 0,	// full
	CROSSBOW_IDLE2,		// empty
	CROSSBOW_FIDGET1,	// full
	CROSSBOW_FIDGET2,	// empty
	CROSSBOW_FIRE1,		// full
	CROSSBOW_FIRE2,		// reload
	CROSSBOW_FIRE3,		// empty
	CROSSBOW_RELOAD,	// from empty
	CROSSBOW_DRAW1,		// full
	CROSSBOW_DRAW2,		// empty
	CROSSBOW_HOLSTER1,	// full
	CROSSBOW_HOLSTER2,	// empty
};

//=====================
// EV_BoltCallback
// This function is used to correct the origin and angles 
// of the bolt, so it looks like it's stuck on the wall.
//=====================
void EV_BoltCallback ( struct tempent_s *ent, float frametime, float currenttime )
{
	ent->entity.origin = ent->entity.baseline.vuser1;
	ent->entity.angles = ent->entity.baseline.vuser2;
}

void EV_FireCrossbow2( event_args_t *args )
{
	vec3_t vecSrc, vecEnd;
	vec3_t up, right, forward;
	pmtrace_t tr;

	int idx;
	vec3_t origin;
	vec3_t angles;
	vec3_t velocity;

	idx = args->entindex;
	VectorCopy( args->origin, origin );
	VectorCopy( args->angles, angles );

	VectorCopy( args->velocity, velocity );
	
	AngleVectors( angles, forward, right, up );

	EV_GetGunPosition( args, vecSrc, origin );

	VectorMA( vecSrc, 8192, forward, vecEnd );

	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""weapons/xbow_fire1.wav"", 1, ATTN_NORM, 0, 93 + gEngfuncs.pfnRandomLong(0,0xF) );
	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_ITEM, ""weapons/xbow_reload1.wav"", gEngfuncs.pfnRandomFloat(0.95, 1.0), ATTN_NORM, 0, 93 + gEngfuncs.pfnRandomLong(0,0xF) );

	if ( EV_IsLocal( idx ) )
	{
		if ( args->iparam1 )
			gEngfuncs.pEventAPI->EV_WeaponAnimation( CROSSBOW_FIRE1, 1 );
		else if ( args->iparam2 )
			gEngfuncs.pEventAPI->EV_WeaponAnimation( CROSSBOW_FIRE3, 1 );
	}

	// Store off the old count
	gEngfuncs.pEventAPI->EV_PushPMStates();

	// Now add in all of the players.
	gEngfuncs.pEventAPI->EV_SetSolidPlayers ( idx - 1 );	
	gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
	gEngfuncs.pEventAPI->EV_PlayerTrace( vecSrc, vecEnd, PM_STUDIO_BOX, -1, &tr );
	
	//We hit something
	if ( tr.fraction < 1.0 )
	{
		physent_t *pe = gEngfuncs.pEventAPI->EV_GetPhysent( tr.ent ); 

		//Not the world, let's assume we hit something organic ( dog, cat, uncle joe, etc ).
		if ( pe->solid != SOLID_BSP )
		{
			switch( gEngfuncs.pfnRandomLong(0,1) )
			{
			case 0:
				gEngfuncs.pEventAPI->EV_PlaySound( idx, tr.endpos, CHAN_BODY, ""weapons/xbow_hitbod1.wav"", 1, ATTN_NORM, 0, PITCH_NORM ); break;
			case 1:
				gEngfuncs.pEventAPI->EV_PlaySound( idx, tr.endpos, CHAN_BODY, ""weapons/xbow_hitbod2.wav"", 1, ATTN_NORM, 0, PITCH_NORM ); break;
			}
		}
		//Stick to world but don't stick to glass, it might break and leave the bolt floating. It can still stick to other non-transparent breakables though.
		else if ( pe->rendermode == kRenderNormal ) 
		{
			gEngfuncs.pEventAPI->EV_PlaySound( 0, tr.endpos, CHAN_BODY, ""weapons/xbow_hit1.wav"", gEngfuncs.pfnRandomFloat(0.95, 1.0), ATTN_NORM, 0, PITCH_NORM );
		
			//Not underwater, do some sparks...
			if ( gEngfuncs.PM_PointContents( tr.endpos, NULL ) != CONTENTS_WATER)
				 gEngfuncs.pEfxAPI->R_SparkShower( tr.endpos );

			vec3_t vBoltAngles;
			int iModelIndex = gEngfuncs.pEventAPI->EV_FindModelIndex( ""models/crossbow_bolt.mdl"" );

			VectorAngles( forward, vBoltAngles );

			TEMPENTITY *bolt = gEngfuncs.pEfxAPI->R_TempModel( tr.endpos - forward * 10, Vector( 0, 0, 0), vBoltAngles , 5, iModelIndex, TE_BOUNCE_NULL );
			
			if ( bolt )
			{
				bolt->flags |= ( FTENT_CLIENTCUSTOM ); //So it calls the callback function.
				bolt->entity.baseline.vuser1 = tr.endpos - forward * 10; // Pull out a little bit
				bolt->entity.baseline.vuser2 = vBoltAngles; //Look forward!
				bolt->callback = EV_BoltCallback; //So we can set the angles and origin back. (Stick the bolt to the wall)
			}
		}
	}

	gEngfuncs.pEventAPI->EV_PopPMStates();
}

//TODO: Fully predict the fliying bolt.
void EV_FireCrossbow( event_args_t *args )
{
	int idx;
	vec3_t origin;

	idx = args->entindex;
	VectorCopy( args->origin, origin );
	
	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""weapons/xbow_fire1.wav"", 1, ATTN_NORM, 0, 93 + gEngfuncs.pfnRandomLong(0,0xF) );
	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_ITEM, ""weapons/xbow_reload1.wav"", gEngfuncs.pfnRandomFloat(0.95, 1.0), ATTN_NORM, 0, 93 + gEngfuncs.pfnRandomLong(0,0xF) );

	//Only play the weapon anims if I shot it. 
	if ( EV_IsLocal( idx ) )
	{
		if ( args->iparam1 )
			gEngfuncs.pEventAPI->EV_WeaponAnimation( CROSSBOW_FIRE1, 1 );
		else if ( args->iparam2 )
			gEngfuncs.pEventAPI->EV_WeaponAnimation( CROSSBOW_FIRE3, 1 );

		V_PunchAxis( 0, -2.0 );
	}
}
//======================
//	   CROSSBOW END 
//======================

//======================
//	    RPG START 
//======================
enum rpg_e {
	RPG_IDLE = 0,
	RPG_FIDGET,
	RPG_RELOAD,		// to reload
	RPG_FIRE2,		// to empty
	RPG_HOLSTER1,	// loaded
	RPG_DRAW1,		// loaded
	RPG_HOLSTER2,	// unloaded
	RPG_DRAW_UL,	// unloaded
	RPG_IDLE_UL,	// unloaded idle
	RPG_FIDGET_UL,	// unloaded fidget
};

void EV_FireRpg( event_args_t *args )
{
	int idx;
	vec3_t origin;

	idx = args->entindex;
	VectorCopy( args->origin, origin );
	
	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""weapons/rocketfire1.wav"", 0.9, ATTN_NORM, 0, PITCH_NORM );
	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_ITEM, ""weapons/glauncher.wav"", 0.7, ATTN_NORM, 0, PITCH_NORM );

	//Only play the weapon anims if I shot it. 
	if ( EV_IsLocal( idx ) )
	{
		gEngfuncs.pEventAPI->EV_WeaponAnimation( RPG_FIRE2, 1 );
	
		V_PunchAxis( 0, -5.0 );
	}
}
//======================
//	     RPG END 
//======================

//======================
//	    EGON END 
//======================
enum egon_e {
	EGON_IDLE1 = 0,
	EGON_FIDGET1,
	EGON_ALTFIREON,
	EGON_ALTFIRECYCLE,
	EGON_ALTFIREOFF,
	EGON_FIRE1,
	EGON_FIRE2,
	EGON_FIRE3,
	EGON_FIRE4,
	EGON_DRAW,
	EGON_HOLSTER
};

int g_fireAnims1[] = { EGON_FIRE1, EGON_FIRE2, EGON_FIRE3, EGON_FIRE4 };
int g_fireAnims2[] = { EGON_ALTFIRECYCLE };

enum EGON_FIRESTATE { FIRE_OFF, FIRE_CHARGE };
enum EGON_FIREMODE { FIRE_NARROW, FIRE_WIDE};

#define	EGON_PRIMARY_VOLUME		450
#define EGON_BEAM_SPRITE		""sprites/xbeam1.spr""
#define EGON_FLARE_SPRITE		""sprites/XSpark1.spr""
#define EGON_SOUND_OFF			""weapons/egon_off1.wav""
#define EGON_SOUND_RUN			""weapons/egon_run3.wav""
#define EGON_SOUND_STARTUP		""weapons/egon_windup2.wav""

#define ARRAYSIZE(p)		(sizeof(p)/sizeof(p[0]))

BEAM *pBeam;
BEAM *pBeam2;

void EV_EgonFire( event_args_t *args )
{
	int idx, iFireState, iFireMode;
	vec3_t origin;

	idx = args->entindex;
	VectorCopy( args->origin, origin );
	iFireState = args->iparam1;
	iFireMode = args->iparam2;
	int iStartup = args->bparam1;


	if ( iStartup )
	{
		if ( iFireMode == FIRE_WIDE )
			gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, EGON_SOUND_STARTUP, 0.98, ATTN_NORM, 0, 125 );
		else
			gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, EGON_SOUND_STARTUP, 0.9, ATTN_NORM, 0, 100 );
	}
	else
	{
		if ( iFireMode == FIRE_WIDE )
			gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_STATIC, EGON_SOUND_RUN, 0.98, ATTN_NORM, 0, 125 );
		else
			gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_STATIC, EGON_SOUND_RUN, 0.9, ATTN_NORM, 0, 100 );
	}

	//Only play the weapon anims if I shot it.
	if ( EV_IsLocal( idx ) )
		gEngfuncs.pEventAPI->EV_WeaponAnimation ( g_fireAnims1[ gEngfuncs.pfnRandomLong( 0, 3 ) ], 1 );

	if ( iStartup == 1 && EV_IsLocal( idx ) && !pBeam && !pBeam2 && cl_lw->value ) //Adrian: Added the cl_lw check for those lital people that hate weapon prediction.
	{
		vec3_t vecSrc, vecEnd, origin, angles, forward, right, up;
		pmtrace_t tr;

		cl_entity_t *pl = gEngfuncs.GetEntityByIndex( idx );

		if ( pl )
		{
			VectorCopy( gHUD.m_vecAngles, angles );
			
			AngleVectors( angles, forward, right, up );

			EV_GetGunPosition( args, vecSrc, pl->origin );

			VectorMA( vecSrc, 2048, forward, vecEnd );

			gEngfuncs.pEventAPI->EV_SetUpPlayerPrediction( false, true );	
				
			// Store off the old count
			gEngfuncs.pEventAPI->EV_PushPMStates();
			
			// Now add in all of the players.
			gEngfuncs.pEventAPI->EV_SetSolidPlayers ( idx - 1 );	

			gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
			gEngfuncs.pEventAPI->EV_PlayerTrace( vecSrc, vecEnd, PM_STUDIO_BOX, -1, &tr );

			gEngfuncs.pEventAPI->EV_PopPMStates();

			int iBeamModelIndex = gEngfuncs.pEventAPI->EV_FindModelIndex( EGON_BEAM_SPRITE );

			float r = 50.0f;
			float g = 50.0f;
			float b = 125.0f;

			if ( IEngineStudio.IsHardware() )
			{
				r /= 100.0f;
				g /= 100.0f;
			}
				
		
			pBeam = gEngfuncs.pEfxAPI->R_BeamEntPoint ( idx | 0x1000, tr.endpos, iBeamModelIndex, 99999, 3.5, 0.2, 0.7, 55, 0, 0, r, g, b );

			if ( pBeam )
				 pBeam->flags |= ( FBEAM_SINENOISE );
 
			pBeam2 = gEngfuncs.pEfxAPI->R_BeamEntPoint ( idx | 0x1000, tr.endpos, iBeamModelIndex, 99999, 5.0, 0.08, 0.7, 25, 0, 0, r, g, b );
		}
	}
}

void EV_EgonStop( event_args_t *args )
{
	int idx;
	vec3_t origin;

	idx = args->entindex;
	VectorCopy ( args->origin, origin );

	gEngfuncs.pEventAPI->EV_StopSound( idx, CHAN_STATIC, EGON_SOUND_RUN );
	
	if ( args->iparam1 )
		 gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, EGON_SOUND_OFF, 0.98, ATTN_NORM, 0, 100 );

	if ( EV_IsLocal( idx ) ) 
	{
		if ( pBeam )
		{
			pBeam->die = 0.0;
			pBeam = NULL;
		}
			
		
		if ( pBeam2 )
		{
			pBeam2->die = 0.0;
			pBeam2 = NULL;
		}
	}
}
//======================
//	    EGON END 
//======================

//======================
//	   HORNET START
//======================
enum hgun_e {
	HGUN_IDLE1 = 0,
	HGUN_FIDGETSWAY,
	HGUN_FIDGETSHAKE,
	HGUN_DOWN,
	HGUN_UP,
	HGUN_SHOOT
};

void EV_HornetGunFire( event_args_t *args )
{
	int idx, iFireMode;
	vec3_t origin, angles, vecSrc, forward, right, up;

	idx = args->entindex;
	VectorCopy( args->origin, origin );
	VectorCopy( args->angles, angles );
	iFireMode = args->iparam1;

	//Only play the weapon anims if I shot it.
	if ( EV_IsLocal( idx ) )
	{
		V_PunchAxis( 0, gEngfuncs.pfnRandomLong ( 0, 2 ) );
		gEngfuncs.pEventAPI->EV_WeaponAnimation ( HGUN_SHOOT, 1 );
	}

	switch ( gEngfuncs.pfnRandomLong ( 0 , 2 ) )
	{
		case 0:	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""agrunt/ag_fire1.wav"", 1, ATTN_NORM, 0, 100 );	break;
		case 1:	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""agrunt/ag_fire2.wav"", 1, ATTN_NORM, 0, 100 );	break;
		case 2:	gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_WEAPON, ""agrunt/ag_fire3.wav"", 1, ATTN_NORM, 0, 100 );	break;
	}
}
//======================
//	   HORNET END
//======================

//======================
//	   TRIPMINE START
//======================
enum tripmine_e {
	TRIPMINE_IDLE1 = 0,
	TRIPMINE_IDLE2,
	TRIPMINE_ARM1,
	TRIPMINE_ARM2,
	TRIPMINE_FIDGET,
	TRIPMINE_HOLSTER,
	TRIPMINE_DRAW,
	TRIPMINE_WORLD,
	TRIPMINE_GROUND,
};

//We only check if it's possible to put a trip mine
//and if it is, then we play the animation. Server still places it.
void EV_TripmineFire( event_args_t *args )
{
	int idx;
	vec3_t vecSrc, angles, view_ofs, forward;
	pmtrace_t tr;

	idx = args->entindex;
	VectorCopy( args->origin, vecSrc );
	VectorCopy( args->angles, angles );

	AngleVectors ( angles, forward, NULL, NULL );
		
	if ( !EV_IsLocal ( idx ) )
		return;

	// Grab predicted result for local player
	gEngfuncs.pEventAPI->EV_LocalPlayerViewheight( view_ofs );

	vecSrc = vecSrc + view_ofs;

	// Store off the old count
	gEngfuncs.pEventAPI->EV_PushPMStates();

	// Now add in all of the players.
	gEngfuncs.pEventAPI->EV_SetSolidPlayers ( idx - 1 );	
	gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
	gEngfuncs.pEventAPI->EV_PlayerTrace( vecSrc, vecSrc + forward * 128, PM_NORMAL, -1, &tr );

	//Hit something solid
	if ( tr.fraction < 1.0 )
		 gEngfuncs.pEventAPI->EV_WeaponAnimation ( TRIPMINE_DRAW, 0 );
	
	gEngfuncs.pEventAPI->EV_PopPMStates();
}
//======================
//	   TRIPMINE END
//======================

//======================
//	   SQUEAK START
//======================
enum squeak_e {
	SQUEAK_IDLE1 = 0,
	SQUEAK_FIDGETFIT,
	SQUEAK_FIDGETNIP,
	SQUEAK_DOWN,
	SQUEAK_UP,
	SQUEAK_THROW
};

#define VEC_HULL_MIN		Vector(-16, -16, -36)
#define VEC_DUCK_HULL_MIN	Vector(-16, -16, -18 )

void EV_SnarkFire( event_args_t *args )
{
	int idx;
	vec3_t vecSrc, angles, view_ofs, forward;
	pmtrace_t tr;

	idx = args->entindex;
	VectorCopy( args->origin, vecSrc );
	VectorCopy( args->angles, angles );

	AngleVectors ( angles, forward, NULL, NULL );
		
	if ( !EV_IsLocal ( idx ) )
		return;
	
	if ( args->ducking )
		vecSrc = vecSrc - ( VEC_HULL_MIN - VEC_DUCK_HULL_MIN );
	
	// Store off the old count
	gEngfuncs.pEventAPI->EV_PushPMStates();

	// Now add in all of the players.
	gEngfuncs.pEventAPI->EV_SetSolidPlayers ( idx - 1 );	
	gEngfuncs.pEventAPI->EV_SetTraceHull( 2 );
	gEngfuncs.pEventAPI->EV_PlayerTrace( vecSrc + forward * 20, vecSrc + forward * 64, PM_NORMAL, -1, &tr );

	//Find space to drop the thing.
	if ( tr.allsolid == 0 && tr.startsolid == 0 && tr.fraction > 0.25 )
		 gEngfuncs.pEventAPI->EV_WeaponAnimation ( SQUEAK_THROW, 0 );
	
	gEngfuncs.pEventAPI->EV_PopPMStates();
}
//======================
//	   SQUEAK END
//======================

void EV_TrainPitchAdjust( event_args_t *args )
{
	int idx;
	vec3_t origin;

	unsigned short us_params;
	int noise;
	float m_flVolume;
	int pitch;
	int stop;
	
	char sz[ 256 ];

	idx = args->entindex;
	
	VectorCopy( args->origin, origin );

	us_params = (unsigned short)args->iparam1;
	stop	  = args->bparam1;

	m_flVolume	= (float)(us_params & 0x003f)/40.0;
	noise		= (int)(((us_params) >> 12 ) & 0x0007);
	pitch		= (int)( 10.0 * (float)( ( us_params >> 6 ) & 0x003f ) );

	switch ( noise )
	{
	case 1: strcpy( sz, ""plats/ttrain1.wav""); break;
	case 2: strcpy( sz, ""plats/ttrain2.wav""); break;
	case 3: strcpy( sz, ""plats/ttrain3.wav""); break; 
	case 4: strcpy( sz, ""plats/ttrain4.wav""); break;
	case 5: strcpy( sz, ""plats/ttrain6.wav""); break;
	case 6: strcpy( sz, ""plats/ttrain7.wav""); break;
	default:
		// no sound
		strcpy( sz, """" );
		return;
	}

	if ( stop )
	{
		gEngfuncs.pEventAPI->EV_StopSound( idx, CHAN_STATIC, sz );
	}
	else
	{
		gEngfuncs.pEventAPI->EV_PlaySound( idx, origin, CHAN_STATIC, sz, m_flVolume, ATTN_NORM, SND_CHANGE_PITCH, pitch );
	}
}

int EV_TFC_IsAllyTeam( int iTeam1, int iTeam2 )
{
	return 0;
}",16152,True,3251.182110954953,median
"/**
 * Copyright 2020 The Magma Authors.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree.
 *
 * 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 <sstream>
#ifdef __cplusplus
extern ""C"" {
#endif
#include ""lte/gateway/c/core/oai/common/log.h""
#include ""lte/gateway/c/core/oai/lib/itti/intertask_interface_types.h""
#include ""lte/gateway/c/core/oai/lib/itti/intertask_interface.h""
#include ""lte/gateway/c/core/oai/lib/directoryd/directoryd.h""
#include ""lte/gateway/c/core/oai/include/amf_config.h""
#include ""lte/gateway/c/core/oai/common/dynamic_memory_check.h""
#ifdef __cplusplus
}
#endif
#include ""lte/gateway/c/core/oai/common/common_defs.h""
#include ""lte/gateway/c/core/oai/common/conversions.h""
#include ""lte/gateway/c/core/oai/tasks/amf/include/amf_pdu_session_configs.h""
#include ""lte/gateway/c/core/oai/tasks/amf/include/amf_session_manager_pco.h""
#include ""lte/gateway/c/core/oai/tasks/amf/amf_app_ue_context_and_proc.h""
#include ""lte/gateway/c/core/oai/tasks/amf/amf_asDefs.h""
#include ""lte/gateway/c/core/oai/tasks/amf/amf_sap.h""
#include ""lte/gateway/c/core/oai/tasks/amf/amf_recv.h""
#include ""lte/gateway/c/core/oai/tasks/amf/amf_app_state_manager.h""
#include ""lte/gateway/c/core/oai/tasks/nas5g/include/M5gNasMessage.h""
#include ""lte/gateway/c/core/oai/include/n11_messages_types.h""
#include ""lte/gateway/c/core/oai/tasks/amf/amf_app_timer_management.h""
#include ""lte/gateway/c/core/oai/tasks/amf/amf_common.h""

extern amf_config_t amf_config;
extern amf_config_t amf_config;
namespace magma5g {
extern task_zmq_ctx_s amf_app_task_zmq_ctx;

//------------------------------------------------------------------------------
void amf_ue_context_update_coll_keys(
    amf_ue_context_t* const amf_ue_context_p, ue_m5gmm_context_s* ue_context_p,
    const gnb_ngap_id_key_t gnb_ngap_id_key,
    const amf_ue_ngap_id_t amf_ue_ngap_id, const imsi64_t imsi,
    const teid_t amf_teid_n11, const guti_m5_t* const guti_p) {
  hashtable_rc_t h_rc                 = HASH_TABLE_OK;
  hash_table_ts_t* amf_state_ue_id_ht = get_amf_ue_state();
  OAILOG_FUNC_IN(LOG_AMF_APP);
  OAILOG_TRACE(
      LOG_AMF_APP,
      ""Existing ue context, old_gnb_ue_ngap_id_key %ld ""
      ""old_amf_ue_ngap_id "" AMF_UE_NGAP_ID_FMT ""old_IMSI "" IMSI_64_FMT
      ""old_GUTI "" GUTI_FMT ""\\n"",
      ue_context_p->gnb_ngap_id_key, ue_context_p->amf_ue_ngap_id,
      ue_context_p->amf_context.imsi64,
      GUTI_ARG_M5G(&ue_context_p->amf_context._guti));

  if ((gnb_ngap_id_key != INVALID_GNB_UE_NGAP_ID_KEY) &&
      (ue_context_p->gnb_ngap_id_key != gnb_ngap_id_key)) {
    h_rc = hashtable_uint64_ts_remove(
        amf_ue_context_p->gnb_ue_ngap_id_ue_context_htbl,
        (const hash_key_t) ue_context_p->gnb_ngap_id_key);
    h_rc = hashtable_uint64_ts_insert(
        amf_ue_context_p->gnb_ue_ngap_id_ue_context_htbl,
        (const hash_key_t) gnb_ngap_id_key, amf_ue_ngap_id);

    if (HASH_TABLE_OK != h_rc) {
      OAILOG_ERROR_UE(
          LOG_AMF_APP, imsi,
          ""Error could not update this ue context %p ""
          ""gnb_ue_ngap_ue_id "" GNB_UE_NGAP_ID_FMT
          ""amf_ue_ngap_id "" AMF_UE_NGAP_ID_FMT "" %s\\n"",
          ue_context_p, ue_context_p->gnb_ue_ngap_id,
          ue_context_p->amf_ue_ngap_id, hashtable_rc_code2string(h_rc));
    }
    ue_context_p->gnb_ngap_id_key = gnb_ngap_id_key;
  }

  if (amf_ue_ngap_id != INVALID_AMF_UE_NGAP_ID) {
    if (ue_context_p->amf_ue_ngap_id != amf_ue_ngap_id) {
      h_rc = hashtable_ts_remove(
          amf_state_ue_id_ht, (const hash_key_t) ue_context_p->amf_ue_ngap_id,
          reinterpret_cast<void**>(&ue_context_p));
      h_rc = hashtable_ts_insert(
          amf_state_ue_id_ht, (const hash_key_t) amf_ue_ngap_id,
          reinterpret_cast<void*>(ue_context_p));

      if (HASH_TABLE_OK != h_rc) {
        OAILOG_ERROR(
            LOG_AMF_APP,
            ""Insertion of Hash entry failed for  ""
            ""amf_ue_ngap_id "" AMF_UE_NGAP_ID_FMT PRIX32 "" \\n"",
            amf_ue_ngap_id);
      }

      ue_context_p->amf_ue_ngap_id = amf_ue_ngap_id;
    }
  } else {
    OAILOG_ERROR(
        LOG_AMF_APP, ""Invalid  amf_ue_ngap_id "" AMF_UE_NGAP_ID_FMT PRIX32 "" \\n"",
        amf_ue_ngap_id);
  }

  h_rc = hashtable_uint64_ts_remove(
      amf_ue_context_p->imsi_amf_ue_id_htbl,
      (const hash_key_t) ue_context_p->amf_context.imsi64);

  if (INVALID_AMF_UE_NGAP_ID != amf_ue_ngap_id) {
    h_rc = hashtable_uint64_ts_insert(
        amf_ue_context_p->imsi_amf_ue_id_htbl, (const hash_key_t) imsi,
        amf_ue_ngap_id);
  } else {
    h_rc = HASH_TABLE_KEY_NOT_EXISTS;
  }

  if (HASH_TABLE_OK != h_rc) {
    OAILOG_ERROR(
        LOG_AMF_APP,
        ""Insertion of Hash entry failed for  ""
        ""amf_ue_ngap_id "" AMF_UE_NGAP_ID_FMT PRIX32 "" \\n"",
        amf_ue_ngap_id);
  }

  h_rc = hashtable_uint64_ts_remove(
      amf_ue_context_p->tun11_ue_context_htbl,
      (const hash_key_t) ue_context_p->amf_teid_n11);

  if (INVALID_AMF_UE_NGAP_ID != amf_ue_ngap_id) {
    h_rc = hashtable_uint64_ts_insert(
        amf_ue_context_p->tun11_ue_context_htbl,
        (const hash_key_t) amf_teid_n11, (uint64_t) amf_ue_ngap_id);
  } else {
    h_rc = HASH_TABLE_KEY_NOT_EXISTS;
  }

  if (HASH_TABLE_OK != h_rc) {
    // TODO: this method is deprecated and will be removed once the AMF's
    // context is migrated to map in the upcoming multi-UE PR
    OAILOG_ERROR(
        LOG_AMF_APP,
        ""Insertion of Hash entry failed for  ""
        ""amf_ue_ngap_id "" AMF_UE_NGAP_ID_FMT PRIX32 "" \\n"",
        amf_ue_ngap_id);
  }

  ue_context_p->amf_teid_n11 = amf_teid_n11;

  if (guti_p) {
    if ((guti_p->guamfi.amf_set_id !=
         ue_context_p->amf_context.m5_guti.guamfi.amf_set_id) ||
        (guti_p->guamfi.amf_regionid !=
         ue_context_p->amf_context.m5_guti.guamfi.amf_regionid) ||
        (guti_p->m_tmsi != ue_context_p->amf_context.m5_guti.m_tmsi) ||
        (guti_p->guamfi.plmn.mcc_digit1 !=
         ue_context_p->amf_context.m5_guti.guamfi.plmn.mcc_digit1) ||
        (guti_p->guamfi.plmn.mcc_digit2 !=
         ue_context_p->amf_context.m5_guti.guamfi.plmn.mcc_digit2) ||
        (guti_p->guamfi.plmn.mcc_digit3 !=
         ue_context_p->amf_context.m5_guti.guamfi.plmn.mcc_digit3) ||
        (ue_context_p->amf_ue_ngap_id != INVALID_AMF_UE_NGAP_ID)) {
      h_rc = obj_hashtable_uint64_ts_remove(
          amf_ue_context_p->guti_ue_context_htbl,
          &ue_context_p->amf_context.m5_guti, sizeof(*guti_p));
      if (INVALID_AMF_UE_NGAP_ID != amf_ue_ngap_id) {
        h_rc = obj_hashtable_uint64_ts_insert(
            amf_ue_context_p->guti_ue_context_htbl, (const void* const) guti_p,
            sizeof(*guti_p), (uint64_t) amf_ue_ngap_id);
      } else {
        h_rc = HASH_TABLE_KEY_NOT_EXISTS;
      }
      if (HASH_TABLE_OK != h_rc) {
        // TODO: this method is deprecated and will be removed once the AMF's
        // context is migrated to map in the upcoming multi-UE PR
        OAILOG_ERROR(
            LOG_AMF_APP,
            ""Insertion of Hash entry failed for  ""
            ""amf_ue_ngap_id "" AMF_UE_NGAP_ID_FMT PRIX32 "" \\n"",
            amf_ue_ngap_id);
      }
      ue_context_p->amf_context.m5_guti = *guti_p;
    }
  }
}

/* Insert guti into guti_ue_context_table */
void amf_ue_context_on_new_guti(
    ue_m5gmm_context_t* const ue_context_p, const guti_m5_t* const guti_p) {
  amf_app_desc_t* amf_app_desc_p = get_amf_nas_state(false);

  if (ue_context_p) {
    amf_ue_context_update_coll_keys(
        &amf_app_desc_p->amf_ue_contexts, ue_context_p,
        ue_context_p->gnb_ngap_id_key, ue_context_p->amf_ue_ngap_id,
        ue_context_p->amf_context.imsi64, ue_context_p->amf_teid_n11, guti_p);
  }

  OAILOG_FUNC_OUT(LOG_AMF_APP);
}

//----------------------------------------------------------------------------------------------
/* This is deprecated function and removed in upcoming PRs related to
 * Service request and Periodic Reg updating.*/
static bool amf_app_construct_guti(
    const plmn_t* const plmn_p, const s_tmsi_m5_t* const s_tmsi_p,
    guti_m5_t* const guti_p) {
  /*
   * This is a helper function to construct GUTI from S-TMSI. It uses PLMN id
   * and AMF Group Id of the serving AMF for this purpose.
   *
   */
  bool is_guti_valid =
      false;  // Set to true if serving AMF is found and GUTI is constructed
  uint8_t num_amf             = 0;  // Number of configured AMF in the AMF pool
  guti_p->m_tmsi              = s_tmsi_p->m_tmsi;
  guti_p->guamfi.amf_set_id   = s_tmsi_p->amf_set_id;
  guti_p->guamfi.amf_pointer  = s_tmsi_p->amf_pointer;
  guti_p->guamfi.amf_regionid = amf_config.guamfi.guamfi[0].amf_regionid;
  // Create GUTI by using PLMN Id and AMF-Group Id of serving AMF
  OAILOG_DEBUG(
      LOG_AMF_APP,
      ""Construct GUTI using S-TMSI received form UE and AMG set Id and pointer""
      ""PLMN ""
      ""id from AMF Conf: %0x, %u %u\\n"",
      s_tmsi_p->m_tmsi, s_tmsi_p->amf_set_id, s_tmsi_p->amf_pointer);
  amf_config_read_lock(&amf_config);

  /*
   * Check number of MMEs in the pool.
   * At present it is assumed that one AMF is supported in AMF pool but in
   * case there are more than one AMF configured then search the serving AMF
   * using AMF code. Assumption is that within one PLMN only one pool of AMF
   * will be configured
   */
  if (amf_config.guamfi.nb > 1) {
    OAILOG_DEBUG(LOG_AMF_APP, ""More than one AMFs are configured."");
  }
  for (num_amf = 0; num_amf < amf_config.guamfi.nb; num_amf++) {
    /*Verify that the AMF code within S-TMSI is same as what is configured in
     * AMF conf*/
    if ((plmn_p->mcc_digit2 ==
         amf_config.guamfi.guamfi[num_amf].plmn.mcc_digit2) &&
        (plmn_p->mcc_digit1 ==
         amf_config.guamfi.guamfi[num_amf].plmn.mcc_digit1) &&
        (plmn_p->mnc_digit3 ==
         amf_config.guamfi.guamfi[num_amf].plmn.mnc_digit3) &&
        (plmn_p->mcc_digit3 ==
         amf_config.guamfi.guamfi[num_amf].plmn.mcc_digit3) &&
        (plmn_p->mnc_digit2 ==
         amf_config.guamfi.guamfi[num_amf].plmn.mnc_digit2) &&
        (plmn_p->mnc_digit1 ==
         amf_config.guamfi.guamfi[num_amf].plmn.mnc_digit1) &&
        (guti_p->guamfi.amf_set_id ==
         amf_config.guamfi.guamfi[num_amf].amf_set_id)) {
      break;
    }
  }
  if (num_amf >= amf_config.guamfi.nb) {
    OAILOG_DEBUG(LOG_AMF_APP, ""No AMF serves this UE"");
  } else {
    guti_p->guamfi.plmn        = amf_config.guamfi.guamfi[num_amf].plmn;
    guti_p->guamfi.amf_set_id  = amf_config.guamfi.guamfi[num_amf].amf_set_id;
    guti_p->guamfi.amf_pointer = amf_config.guamfi.guamfi[num_amf].amf_pointer;
    guti_p->guamfi.amf_regionid =
        amf_config.guamfi.guamfi[num_amf].amf_regionid;
    is_guti_valid = true;
  }

  amf_config_unlock(&amf_config);
  return is_guti_valid;
}

//------------------------------------------------------------------------------
// Get existing GUTI details
ue_m5gmm_context_s* amf_ue_context_exists_guti(
    amf_ue_context_t* const amf_ue_context_p, const guti_m5_t* const guti_p) {
  hashtable_rc_t h_rc            = HASH_TABLE_OK;
  uint64_t amf_ue_ngap_id64      = 0;
  ue_m5gmm_context_t* ue_context = NULL;

  h_rc = obj_hashtable_uint64_ts_get(
      amf_ue_context_p->guti_ue_context_htbl, (const void*) guti_p,
      sizeof(*guti_p), &amf_ue_ngap_id64);

  if (HASH_TABLE_OK == h_rc) {
    ue_context = amf_ue_context_exists_amf_ue_ngap_id(
        (amf_ue_ngap_id_t) amf_ue_ngap_id64);
    if (ue_context) {
      return ue_context;
    }
  }

  if (!ue_context) {
    OAILOG_WARNING(
        LOG_AMF_APP, ""No GUTI hashtable for GUTI Hash %x"", guti_p->m_tmsi);
    ue_context = ue_context_loopkup_by_guti(guti_p->m_tmsi);
    if (ue_context) {
      return ue_context;
    }
  }

  return NULL;
}

//-----------------------------------------------------------------------------------------
/****************************************************************************
 **                                                                        **
 ** Name:    amf_handle_initial_ue_message()                                **
 **                                                                        **
 ** Description: Processes Initial UE message                              **
 **                                                                        **
 ** Inputs:  amf_app_desc_p:    amf application descriptors                **
 **      initial_pP:      ngap initial ue message structure                **
 **                                                                        **
 **      Return:    imsi value                                             **
 **                                                                        **
 ***************************************************************************/
imsi64_t amf_app_handle_initial_ue_message(
    amf_app_desc_t* amf_app_desc_p,
    itti_ngap_initial_ue_message_t* const initial_pP) {
  OAILOG_FUNC_IN(LOG_AMF_APP);
  ue_m5gmm_context_s* ue_context_p  = NULL;
  bool is_guti_valid                = false;
  bool is_mm_ctx_new                = false;
  gnb_ngap_id_key_t gnb_ngap_id_key = INVALID_GNB_UE_NGAP_ID_KEY;
  imsi64_t imsi64                   = INVALID_IMSI64;
  guti_m5_t guti                    = {0};
  plmn_t plmn                       = {0};
  s_tmsi_m5_t s_tmsi                = {0};
  amf_ue_ngap_id_t amf_ue_ngap_id   = INVALID_AMF_UE_NGAP_ID;

  if (initial_pP->amf_ue_ngap_id != INVALID_AMF_UE_NGAP_ID) {
    OAILOG_ERROR(
        LOG_AMF_APP,
        ""AMF UE NGAP Id ("" AMF_UE_NGAP_ID_FMT "") is already assigned\\n"",
        initial_pP->amf_ue_ngap_id);
  }

  // Check if there is any existing UE context using S-TMSI/GUTI
  if (initial_pP->is_s_tmsi_valid) {
    /* This check is not used in this PR and code got changed in upcoming PRs
     * hence not-used functions are take out
     */
    OAILOG_DEBUG(
        LOG_AMF_APP,
        ""INITIAL UE Message: Valid amf_set_id and S-TMSI received "");
    guti.guamfi.plmn         = {0};
    guti.guamfi.amf_regionid = 0;
    guti.guamfi.amf_set_id   = 0;
    guti.guamfi.amf_pointer  = 0;
    guti.m_tmsi              = INVALID_M_TMSI;
    plmn.mcc_digit1          = initial_pP->tai.plmn.mcc_digit1;
    plmn.mcc_digit2          = initial_pP->tai.plmn.mcc_digit2;
    plmn.mcc_digit3          = initial_pP->tai.plmn.mcc_digit3;
    plmn.mnc_digit1          = initial_pP->tai.plmn.mnc_digit1;
    plmn.mnc_digit2          = initial_pP->tai.plmn.mnc_digit2;
    plmn.mnc_digit3          = initial_pP->tai.plmn.mnc_digit3;
    is_guti_valid =
        amf_app_construct_guti(&plmn, &(initial_pP->opt_s_tmsi), &guti);
    // create a new ue context if nothing is found
    if (is_guti_valid) {
      ue_context_p =
          amf_ue_context_exists_guti(&amf_app_desc_p->amf_ue_contexts, &guti);
      if (ue_context_p) {
        initial_pP->amf_ue_ngap_id = ue_context_p->amf_ue_ngap_id;
        if (ue_context_p->gnb_ngap_id_key != INVALID_GNB_UE_NGAP_ID_KEY) {
          /*
           * Ideally this should never happen. When UE moves to IDLE,
           * this key is set to INVALID.
           * Note - This can happen if eNB detects RLF late and by that time
           * UE sends Initial NAS message via new RRC connection.
           * However if this key is valid, remove the key from the hashtable.
           */
          OAILOG_ERROR(
              LOG_AMF_APP,
              ""AMF_APP_INITAIL_UE_MESSAGE: gnb_ngap_id_key %ld has ""
              ""valid value \\n"",
              ue_context_p->gnb_ngap_id_key);
          ue_context_release_command(
              ue_context_p->amf_ue_ngap_id, ue_context_p->gnb_ue_ngap_id,
              NGAP_NAS_NORMAL_RELEASE);
          hashtable_uint64_ts_remove(
              amf_app_desc_p->amf_ue_contexts.gnb_ue_ngap_id_ue_context_htbl,
              (const hash_key_t) ue_context_p->gnb_ngap_id_key);
          ue_context_p->gnb_ngap_id_key = INVALID_GNB_UE_NGAP_ID_KEY;
        }

        /* remove amf_ngap_ud_id entry from ue context */
        amf_remove_ue_context(ue_context_p);

        // Update AMF UE context with new gnb_ue_ngap_id
        ue_context_p->gnb_ue_ngap_id = initial_pP->gnb_ue_ngap_id;

        AMF_APP_GNB_NGAP_ID_KEY(
            gnb_ngap_id_key, initial_pP->gnb_id, initial_pP->gnb_ue_ngap_id);

        // generate new amf_ngap_ue_id
        amf_ue_ngap_id = amf_app_ctx_get_new_ue_id(
            &amf_app_desc_p->amf_app_ue_ngap_id_generator);

        amf_ue_context_update_coll_keys(
            &amf_app_desc_p->amf_ue_contexts, ue_context_p, gnb_ngap_id_key,
            amf_ue_ngap_id, ue_context_p->amf_context.imsi64,
            ue_context_p->amf_teid_n11, &guti);

        amf_insert_ue_context(
            ue_context_p->amf_ue_ngap_id, &amf_app_desc_p->amf_ue_contexts,
            ue_context_p);
        imsi64 = ue_context_p->amf_context.imsi64;
      }
    } else {
      // TODO This piece of code got changed in upcoming PRs with feature
      // like Service Req and Periodic Reg Updating.
    }
  } else {
    OAILOG_DEBUG(
        LOG_AMF_APP, ""AMF_APP_INITIAL_UE_MESSAGE from NGAP,without S-TMSI. \\n"");
  }

  /* Five_G_TMSI not configured */
  if (ue_context_p == NULL) {
    /* Check if Context can be found by GNB UE ID */
    ue_context_p = ue_context_lookup_by_gnb_ue_id(initial_pP->gnb_ue_ngap_id);

    /* Make sure its with same connection */
    if (ue_context_p &&
        (initial_pP->sctp_assoc_id != ue_context_p->sctp_assoc_id_key)) {
      ue_context_p = NULL;
    }
  }

  /*
   * UE Context already present in AMF. This can happen during PERIODIC
   * Registration. Steps for Periodic Registration:
   *   1. Context Setup and Guti established.
   *   2. UEContext Release Sequence
   *   3. InitialUEContextSetup Request from GNB with type as periodic
   *      registration
   */
  if (ue_context_p && ue_context_p->amf_ue_ngap_id != INVALID_AMF_UE_NGAP_ID) {
    /* If NGAP is not aware of ue_id or fiveGTmsi Is received
     * send the ue_id notification.
     */
    if ((initial_pP->amf_ue_ngap_id == INVALID_AMF_UE_NGAP_ID) ||
        (initial_pP->is_s_tmsi_valid)) {
      /* Sync data between AMF and NGAP */
      if (initial_pP->sctp_assoc_id == ue_context_p->sctp_assoc_id_key) {
        notify_ngap_new_ue_amf_ngap_id_association(ue_context_p);
      }
    }
  }

  // create a new ue context if nothing is found
  if (ue_context_p == NULL) {
    if (!(ue_context_p = amf_create_new_ue_context())) {
      OAILOG_ERROR(LOG_AMF_APP, ""Failed to create ue_m5gmm_context for ue \\n"");
      OAILOG_FUNC_RETURN(LOG_AMF_APP, imsi64);
    }

    // Allocate new amf_ue_ngap_id
    ue_context_p->amf_ue_ngap_id = amf_app_ctx_get_new_ue_id(
        &amf_app_desc_p->amf_app_ue_ngap_id_generator);

    if (ue_context_p->amf_ue_ngap_id == INVALID_AMF_UE_NGAP_ID) {
      OAILOG_ERROR(LOG_AMF_APP, ""amf_ue_ngap_id allocation failed.\\n"");
      amf_remove_ue_context(ue_context_p);
      OAILOG_FUNC_RETURN(LOG_AMF_APP, imsi64);
    }

    OAILOG_DEBUG(
        LOG_AMF_APP,
        ""Creating new ue_m5gmm_context: [%p]""
        ""for amf_ue_ngap_id: ["" AMF_UE_NGAP_ID_FMT ""]"",
        ue_context_p, ue_context_p->amf_ue_ngap_id);

    AMF_APP_GNB_NGAP_ID_KEY(
        ue_context_p->gnb_ngap_id_key, initial_pP->gnb_id,
        initial_pP->gnb_ue_ngap_id);
    amf_insert_ue_context(
        ue_context_p->amf_ue_ngap_id, &amf_app_desc_p->amf_ue_contexts,
        ue_context_p);
  }
  ue_context_p->sctp_assoc_id_key = initial_pP->sctp_assoc_id;
  ue_context_p->gnb_ue_ngap_id    = initial_pP->gnb_ue_ngap_id;

  // UEContextRequest
  ue_context_p->ue_context_request = initial_pP->ue_context_request;
  OAILOG_DEBUG(
      LOG_AMF_APP, ""UE context request received: %d\\n "",
      ue_context_p->ue_context_request);

  notify_ngap_new_ue_amf_ngap_id_association(ue_context_p);
  if (initial_pP->is_s_tmsi_valid) {
    s_tmsi = initial_pP->opt_s_tmsi;
  } else {
    s_tmsi.amf_pointer = 0;
    s_tmsi.m_tmsi      = INVALID_M_TMSI;
    OAILOG_DEBUG(
        LOG_AMF_APP,
        "" Sending nas establishment indication to nas for ue_id = ""
        ""("" AMF_UE_NGAP_ID_FMT "")"",
        ue_context_p->amf_ue_ngap_id);
  }
  is_mm_ctx_new = true;

  OAILOG_DEBUG(
      LOG_AMF_APP,
      "" Sending NAS Establishment Indication to NAS for ue_id = ""
      ""("" AMF_UE_NGAP_ID_FMT "")"",
      ue_context_p->amf_ue_ngap_id);

  amf_ue_ngap_id_t ue_id = ue_context_p->amf_ue_ngap_id;

  nas_proc_establish_ind(
      ue_context_p->amf_ue_ngap_id, is_mm_ctx_new, initial_pP->tai,
      initial_pP->ecgi, initial_pP->m5g_rrc_establishment_cause, s_tmsi,
      initial_pP->nas);

  initial_pP->nas = NULL;

  /* In case duplicate attach handling, ue_context_p might be removed
   * Before accessing ue_context_p, we shall validate whether UE context
   * exists or not
   */
  if (INVALID_AMF_UE_NGAP_ID != ue_id) {
    hash_table_ts_t* amf_state_ue_id_ht = get_amf_ue_state();
    if (hashtable_ts_is_key_exists(
            amf_state_ue_id_ht, (const hash_key_t) ue_id) == HASH_TABLE_OK) {
      imsi64 = ue_context_p->amf_context.imsi64;
    }
  }

  OAILOG_FUNC_RETURN(LOG_AMF_APP, imsi64);
}

/****************************************************************************
 **                                                                        **
 ** Name:    amf_handle_uplink_nas_message()                               **
 **                                                                        **
 ** Description: Handle uplink nas message                                 **
 **                                                                        **
 ** Inputs:  amf_app_desc_p:    amf application descriptors                **
 **      msg:      nstring msg                                             **
 **                                                                        **
 **      Return:    RETURNok, RETURNerror                                  **
 **                                                                        **
 ***************************************************************************/
int amf_app_handle_uplink_nas_message(
    amf_app_desc_t* amf_app_desc_p, bstring msg, amf_ue_ngap_id_t ue_id,
    const tai_t originating_tai) {
  OAILOG_FUNC_IN(LOG_NAS_AMF);

  int rc = RETURNerror;
  if (msg) {
    amf_sap_t amf_sap = {};
    /*
     * Notify the AMF procedure call manager that data transfer
     * indication has been received from the Access-Stratum sublayer
     */
    amf_sap.primitive                    = AMFAS_ESTABLISH_REQ;
    amf_sap.u.amf_as.u.establish.ue_id   = ue_id;
    amf_sap.u.amf_as.u.establish.nas_msg = msg;
    amf_sap.u.amf_as.u.establish.tai     = originating_tai;
    msg                                  = NULL;
    rc                                   = amf_sap_send(&amf_sap);
  } else {
    OAILOG_WARNING(
        LOG_NAS,
        ""Received NAS message in uplink is NULL for for UE ""
        ""ID: "" AMF_UE_NGAP_ID_FMT,
        amf_app_desc_p->amf_app_ue_ngap_id_generator);
  }
  OAILOG_FUNC_RETURN(LOG_NAS_AMF, rc);
}

static void get_ambr_unit(
    uint8_t apn_ambr_unit, uint32_t apn_session_ambr, uint8_t* calc_ambr_unit,
    uint16_t* calc_session_ambr) {
  *calc_ambr_unit = 0;

  while (apn_session_ambr) {
    *calc_ambr_unit += 1;

    apn_session_ambr >>= 2;
  }

  *calc_session_ambr = PDU_SESSION_DEFAULT_AMBR;
}

/* Received the session created response message from SMF. Populate and Send
 * PDU Session Resource Setup Request message to gNB and  PDU Session
 * Establishment Accept Message to UE*/
void amf_app_handle_pdu_session_response(
    itti_n11_create_pdu_session_response_t* pdu_session_resp) {
  DLNASTransportMsg encode_msg;
  int amf_rc = RETURNerror;
  ue_m5gmm_context_s* ue_context;
  std::shared_ptr<smf_context_t> smf_ctx;
  amf_smf_t amf_smf_msg;
  // TODO: hardcoded for now, addressed in the upcoming multi-UE PR
  uint64_t ue_id = 0;
  int rc         = RETURNerror;

  imsi64_t imsi64;
  IMSI_STRING_TO_IMSI64(pdu_session_resp->imsi, &imsi64);
  // Handle smf_context
  ue_context = lookup_ue_ctxt_by_imsi(imsi64);
  if (ue_context) {
    smf_ctx = amf_get_smf_context_by_pdu_session_id(
        ue_context, pdu_session_resp->pdu_session_id);
    if (smf_ctx == NULL) {
      OAILOG_ERROR(
          LOG_AMF_APP, ""pdu session  not found for session_id = %u\\n"",
          pdu_session_resp->pdu_session_id);
      return;
    }
    ue_id = ue_context->amf_ue_ngap_id;
  } else {
    OAILOG_ERROR(
        LOG_AMF_APP, ""ue context not found for the imsi=%lu\\n"", imsi64);
    return;
  }

  get_ambr_unit(
      pdu_session_resp->session_ambr.downlink_unit_type,
      pdu_session_resp->session_ambr.downlink_units, &smf_ctx->dl_ambr_unit,
      &smf_ctx->dl_session_ambr);

  get_ambr_unit(
      pdu_session_resp->session_ambr.uplink_unit_type,
      pdu_session_resp->session_ambr.uplink_units, &smf_ctx->ul_ambr_unit,
      &smf_ctx->ul_session_ambr);

  memcpy(
      &(smf_ctx->pdu_resource_setup_req
            .pdu_session_resource_setup_request_transfer
            .qos_flow_setup_request_list),
      &(pdu_session_resp->qos_list), sizeof(qos_flow_request_list_t));
  memcpy(
      smf_ctx->gtp_tunnel_id.upf_gtp_teid_ip_addr,
      pdu_session_resp->upf_endpoint.end_ipv4_addr,
      sizeof(smf_ctx->gtp_tunnel_id.upf_gtp_teid_ip_addr));
  memcpy(
      smf_ctx->gtp_tunnel_id.upf_gtp_teid, pdu_session_resp->upf_endpoint.teid,
      sizeof(smf_ctx->gtp_tunnel_id.upf_gtp_teid));

  smf_ctx->n_active_pdus += 1;

  if (REGISTERED_IDLE == ue_context->mm_state) {
    // pdu session state
    smf_ctx->pdu_session_state            = ACTIVE;
    amf_sap_t amf_sap                     = {};
    amf_sap.primitive                     = AMFAS_ESTABLISH_CNF;
    amf_sap.u.amf_as.u.establish.ue_id    = ue_id;
    amf_sap.u.amf_as.u.establish.nas_info = AMF_AS_NAS_INFO_SR;

    amf_sap.u.amf_as.u.establish.pdu_session_status_ie =
        (AMF_AS_PDU_SESSION_STATUS | AMF_AS_PDU_SESSION_REACTIVATION_STATUS);
    amf_sap.u.amf_as.u.establish.pdu_session_status =
        (1 << smf_ctx->smf_proc_data.pdu_session_identity.pdu_session_id);
    amf_sap.u.amf_as.u.establish.pdu_session_reactivation_status =
        (1 << smf_ctx->smf_proc_data.pdu_session_identity.pdu_session_id);
    amf_sap.u.amf_as.u.establish.guti = ue_context->amf_context.m5_guti;
    rc                                = amf_sap_send(&amf_sap);
    if (RETURNok == rc) {
      ue_context->mm_state = REGISTERED_CONNECTED;
    }
  } else {
    OAILOG_DEBUG(
        LOG_AMF_APP,
        ""Sending message to gNB for PDUSessionResourceSetupRequest ""
        ""**n_active_pdus=%d **\\n"",
        smf_ctx->n_active_pdus);

    amf_smf_msg.pdu_session_id = pdu_session_resp->pdu_session_id;
    /*Execute PDU establishement accept from AMF to gnodeb */
    pdu_state_handle_message(
        // ue_context->mm_state, STATE_PDU_SESSION_ESTABLISHMENT_ACCEPT,
        REGISTERED_CONNECTED, STATE_PDU_SESSION_ESTABLISHMENT_ACCEPT,
        // smf_ctx->pdu_session_state, ue_context, amf_smf_msg, NULL,
        CREATING, ue_context, amf_smf_msg, NULL, pdu_session_resp, ue_id);
  }
}

/****************************************************************************
 **                                                                        **
 ** Name:    amf_app_handle_pdu_session_accept()                           **
 **                                                                        **
 ** Description: Send the PDU establishment accept to gnodeb               **
 **                                                                        **
 ** Inputs:  pdu_session_resp:   pdusession response message               **
 **      ue_id:      ue identity                                           **
 **                                                                        **
 **      Return:    RETURNok, RETURNerror                                  **
 **                                                                        **
 ***************************************************************************/
int amf_app_handle_pdu_session_accept(
    itti_n11_create_pdu_session_response_t* pdu_session_resp, uint64_t ue_id) {
  nas5g_error_code_t rc = M5G_AS_SUCCESS;

  DLNASTransportMsg* encode_msg;
  amf_nas_message_t msg = {};
  uint32_t bytes        = 0;
  uint32_t len          = 0;
  SmfMsg* smf_msg       = nullptr;
  bstring buffer;
  // smf_ctx declared and set but not used, commented to cleanup warnings
  std::shared_ptr<smf_context_t> smf_ctx;
  ue_m5gmm_context_s* ue_context                   = nullptr;
  protocol_configuration_options_t* msg_accept_pco = nullptr;

  // Handle smf_context
  ue_context = amf_ue_context_exists_amf_ue_ngap_id(ue_id);
  if (!ue_context) {
    OAILOG_ERROR(
        LOG_AMF_APP, ""ue context not found for the ue_id:"" AMF_UE_NGAP_ID_FMT,
        ue_id);
    return M5G_AS_FAILURE;
  }

  smf_ctx = amf_get_smf_context_by_pdu_session_id(
      ue_context, pdu_session_resp->pdu_session_id);
  if (!smf_ctx) {
    OAILOG_ERROR(
        LOG_AMF_APP, ""Smf context is not exist UE ID:"" AMF_UE_NGAP_ID_FMT,
        ue_id);
    return M5G_AS_FAILURE;
  }
  // updating session state
  smf_ctx->pdu_session_state = ACTIVE;

  // Message construction for PDU Establishment Accept
  msg.security_protected.plain.amf.header.extended_protocol_discriminator =
      M5G_MOBILITY_MANAGEMENT_MESSAGES;
  msg.security_protected.plain.amf.header.message_type = DLNASTRANSPORT;
  msg.header.security_header_type =
      SECURITY_HEADER_TYPE_INTEGRITY_PROTECTED_CYPHERED;
  msg.header.extended_protocol_discriminator = M5G_MOBILITY_MANAGEMENT_MESSAGES;
  msg.header.sequence_number =
      ue_context->amf_context._security.dl_count.seq_num;

  encode_msg = &msg.security_protected.plain.amf.msg.downlinknas5gtransport;
  smf_msg    = &encode_msg->payload_container.smf_msg;

  // AmfHeader
  encode_msg->extended_protocol_discriminator.extended_proto_discriminator =
      M5G_MOBILITY_MANAGEMENT_MESSAGES;
  encode_msg->spare_half_octet.spare     = 0x00;
  encode_msg->sec_header_type.sec_hdr    = SECURITY_HEADER_TYPE_NOT_PROTECTED;
  encode_msg->message_type.msg_type      = DLNASTRANSPORT;
  encode_msg->payload_container_type.iei = 0;
  // encode_msg->payload_container_type.iei = PAYLOAD_CONTAINER_TYPE;

  // SmfMsg
  encode_msg->payload_container_type.type_val = N1_SM_INFO;
  encode_msg->payload_container.iei           = PAYLOAD_CONTAINER;
  encode_msg->pdu_session_identity.iei =
      static_cast<uint8_t>(M5GIei::PDU_SESSION_IDENTITY_2);
  encode_msg->pdu_session_identity.pdu_session_id =
      pdu_session_resp->pdu_session_id;

  smf_msg->header.extended_protocol_discriminator =
      M5G_SESSION_MANAGEMENT_MESSAGES;
  smf_msg->header.pdu_session_id           = pdu_session_resp->pdu_session_id;
  smf_msg->header.message_type             = PDU_SESSION_ESTABLISHMENT_ACCEPT;
  smf_msg->header.procedure_transaction_id = smf_ctx->smf_proc_data.pti.pti;
  smf_msg->msg.pdu_session_estab_accept.extended_protocol_discriminator
      .extended_proto_discriminator = M5G_SESSION_MANAGEMENT_MESSAGES;
  smf_msg->msg.pdu_session_estab_accept.pdu_session_identity.pdu_session_id =
      pdu_session_resp->pdu_session_id;
  smf_msg->msg.pdu_session_estab_accept.pti.pti =
      smf_ctx->smf_proc_data.pti.pti;
  smf_msg->msg.pdu_session_estab_accept.message_type.msg_type =
      PDU_SESSION_ESTABLISHMENT_ACCEPT;
  smf_msg->msg.pdu_session_estab_accept.pdu_session_type.type_val = 1;
  smf_msg->msg.pdu_session_estab_accept.ssc_mode.mode_val         = 1;

  memset(
      &(smf_msg->msg.pdu_session_estab_accept.pdu_address.address_info), 0, 12);

  for (int i = 0; i < PDU_ADDR_IPV4_LEN; i++) {
    smf_msg->msg.pdu_session_estab_accept.pdu_address.address_info[i] =
        pdu_session_resp->pdu_address.redirect_server_address[i];
  }
  smf_msg->msg.pdu_session_estab_accept.pdu_address.type_val = PDU_ADDR_TYPE;

  /* QOSrules are hardcoded as it is not exchanged in AMF-SMF
   * gRPC calls as of now, handled in upcoming PR
   * TODO: get the rules for the session from SMF and use it here
   */
  smf_msg->msg.pdu_session_estab_accept.qos_rules.length = 0x9;
  QOSRule qos_rule;
  qos_rule.qos_rule_id         = 0x1;
  qos_rule.len                 = 0x6;
  qos_rule.rule_oper_code      = 0x1;
  qos_rule.dqr_bit             = 0x1;
  qos_rule.no_of_pkt_filters   = 0x1;
  qos_rule.qos_rule_precedence = 0xff;
  qos_rule.spare               = 0x0;
  qos_rule.segregation         = 0x0;
  qos_rule.qfi =
      smf_ctx->pdu_resource_setup_req
          .pdu_session_resource_setup_request_transfer
          .qos_flow_setup_request_list.qos_flow_req_item.qos_flow_identifier;
  NewQOSRulePktFilter new_qos_rule_pkt_filter;
  new_qos_rule_pkt_filter.spare          = 0x0;
  new_qos_rule_pkt_filter.pkt_filter_dir = 0x3;
  new_qos_rule_pkt_filter.pkt_filter_id  = 0x1;
  new_qos_rule_pkt_filter.len            = 0x1;
  uint8_t contents                       = 0x1;
  memcpy(
      new_qos_rule_pkt_filter.contents, &contents, new_qos_rule_pkt_filter.len);
  memcpy(
      qos_rule.new_qos_rule_pkt_filter, &new_qos_rule_pkt_filter,
      1 * sizeof(NewQOSRulePktFilter));
  memcpy(
      smf_msg->msg.pdu_session_estab_accept.qos_rules.qos_rule, &qos_rule,
      1 * sizeof(QOSRule));
  smf_msg->msg.pdu_session_estab_accept.session_ambr.dl_unit =
      pdu_session_resp->session_ambr.downlink_unit_type;
  smf_msg->msg.pdu_session_estab_accept.session_ambr.ul_unit =
      pdu_session_resp->session_ambr.uplink_unit_type;
  smf_msg->msg.pdu_session_estab_accept.session_ambr.dl_session_ambr =
      pdu_session_resp->session_ambr.downlink_units;
  smf_msg->msg.pdu_session_estab_accept.session_ambr.ul_session_ambr =
      pdu_session_resp->session_ambr.uplink_units;
  smf_msg->msg.pdu_session_estab_accept.session_ambr.length = AMBR_LEN;

  msg_accept_pco =
      &(smf_msg->msg.pdu_session_estab_accept.protocolconfigurationoptions.pco);

  auto pco_len = sm_process_pco_request(&(smf_ctx->pco), msg_accept_pco);

  encode_msg->payload_container.len =
      PDU_ESTAB_ACCPET_PAYLOAD_CONTAINER_LEN + pco_len;
  len = PDU_ESTAB_ACCEPT_NAS_PDU_LEN + pco_len;

  /* Ciphering algorithms, EEA1 and EEA2 expects length to be mode of 4,
   * so length is modified such that it will be mode of 4
   */
  AMF_GET_BYTE_ALIGNED_LENGTH(len);
  if (msg.header.security_header_type != SECURITY_HEADER_TYPE_NOT_PROTECTED) {
    amf_msg_header* header = &msg.security_protected.plain.amf.header;
    /*
     * Expand size of protected NAS message
     */
    len += NAS_MESSAGE_SECURITY_HEADER_SIZE;
    /*
     * Set header of plain NAS message
     */
    header->extended_protocol_discriminator = M5GS_MOBILITY_MANAGEMENT_MESSAGE;
    header->security_header_type = SECURITY_HEADER_TYPE_NOT_PROTECTED;
  }

  buffer = bfromcstralloc(len, ""\\0"");
  bytes  = nas5g_message_encode(
      buffer->data, &msg, len, &ue_context->amf_context._security);
  if (bytes > 0) {
    buffer->slen = bytes;
    pdu_session_resource_setup_request(ue_context, ue_id, smf_ctx, buffer);

  } else {
    OAILOG_WARNING(LOG_AMF_APP, ""NAS encode failed \\n"");
    bdestroy_wrapper(&buffer);
  }

  /* Clean up the PCO contents */
  sm_free_protocol_configuration_options(&msg_accept_pco);

  return rc;
}

/* Handling PDU Session Resource Setup Response sent from gNB*/
void amf_app_handle_resource_setup_response(
    itti_ngap_pdusessionresource_setup_rsp_t session_seup_resp) {
  amf_ue_ngap_id_t ue_id;

  ue_m5gmm_context_s* ue_context = nullptr;
  std::shared_ptr<smf_context_t> smf_ctx;

  /* Check if failure message is not NULL and if NULL,
   * it is successful message from gNB.
   * Nothing to in this case. If failure message comes from gNB
   * AMF need to report this failed message to SMF
   *
   * NOTE: only handling success part not failure part
   * will be handled later
   */
  OAILOG_DEBUG(
      LOG_AMF_APP, ""Handling uplink PDU session setup response message\\n"");

  if (session_seup_resp.pduSessionResource_setup_list.no_of_items > 0) {
    ue_id = session_seup_resp.amf_ue_ngap_id;

    ue_context = amf_ue_context_exists_amf_ue_ngap_id(ue_id);
    if (ue_context == NULL) {
      OAILOG_ERROR(
          LOG_AMF_APP,
          ""UE context not found for the ue_id = "" AMF_UE_NGAP_ID_FMT, ue_id);
      return;
    }

    smf_ctx = amf_get_smf_context_by_pdu_session_id(
        ue_context,
        session_seup_resp.pduSessionResource_setup_list.item[0].Pdu_Session_ID);
    if (smf_ctx == NULL) {
      OAILOG_ERROR(
          LOG_AMF_APP, ""PDU session  not found for session_id = %lu\\n"",
          session_seup_resp.pduSessionResource_setup_list.item[0]
              .Pdu_Session_ID);
      return;
    }

    /* This is success case and we need not to send message to SMF
     * and drop the message here
     */
    amf_ue_ngap_id_t ue_id;
    amf_smf_establish_t amf_smf_grpc_ies;
    ue_m5gmm_context_s* ue_context = nullptr;
    char imsi[IMSI_BCD_DIGITS_MAX + 1];

    ue_id = session_seup_resp.amf_ue_ngap_id;

    ue_context = amf_ue_context_exists_amf_ue_ngap_id(ue_id);
    // Handling of ue context
    if (!ue_context) {
      OAILOG_ERROR(
          LOG_AMF_APP, ""UE context not found for UE ID: "" AMF_UE_NGAP_ID_FMT,
          ue_id);
    }

    // Store gNB ip and TEID in respective smf_context
    memset(
        &smf_ctx->gtp_tunnel_id.gnb_gtp_teid_ip_addr, '\\0',
        sizeof(smf_ctx->gtp_tunnel_id.gnb_gtp_teid_ip_addr));

    smf_ctx->gtp_tunnel_id
        .gnb_gtp_teid = htonl(*(reinterpret_cast<unsigned int*>(
        session_seup_resp.pduSessionResource_setup_list.item[0]
            .PDU_Session_Resource_Setup_Response_Transfer.tunnel.gTP_TEID)));
    memcpy(
        &smf_ctx->gtp_tunnel_id.gnb_gtp_teid_ip_addr,
        &session_seup_resp.pduSessionResource_setup_list.item[0]
             .PDU_Session_Resource_Setup_Response_Transfer.tunnel
             .transportLayerAddress,
        4);  // time being 4 byte is copying.
    OAILOG_DEBUG(
        LOG_AMF_APP,
        ""gnb_gtp_teid_ipaddr: [%02x %02x %02x %02x]  and gnb_gtp_teid ""
        ""["" GNB_GTP_TEID_FMT ""]\\n"",
        smf_ctx->gtp_tunnel_id.gnb_gtp_teid_ip_addr[0],
        smf_ctx->gtp_tunnel_id.gnb_gtp_teid_ip_addr[1],
        smf_ctx->gtp_tunnel_id.gnb_gtp_teid_ip_addr[2],
        smf_ctx->gtp_tunnel_id.gnb_gtp_teid_ip_addr[3],
        smf_ctx->gtp_tunnel_id.gnb_gtp_teid);
    // Incrementing the  pdu session version
    smf_ctx->pdu_session_version++;
    /*Copy respective gNB fields to amf_smf_establish_t compartible to gRPC
     * message*/
    memset(
        &amf_smf_grpc_ies.gnb_gtp_teid_ip_addr, '\\0',
        sizeof(amf_smf_grpc_ies.gnb_gtp_teid_ip_addr));
    memset(
        &amf_smf_grpc_ies.gnb_gtp_teid, '\\0',
        sizeof(amf_smf_grpc_ies.gnb_gtp_teid));
    memcpy(
        &amf_smf_grpc_ies.gnb_gtp_teid_ip_addr,
        &smf_ctx->gtp_tunnel_id.gnb_gtp_teid_ip_addr, 4);
    memcpy(
        &amf_smf_grpc_ies.gnb_gtp_teid, &smf_ctx->gtp_tunnel_id.gnb_gtp_teid,
        4);
    amf_smf_grpc_ies.pdu_session_id =
        session_seup_resp.pduSessionResource_setup_list.item[0].Pdu_Session_ID;
    // smf_ctx->smf_proc_data.pdu_session_identity.pdu_session_id;

    IMSI64_TO_STRING(ue_context->amf_context.imsi64, imsi, 15);
    /* Prepare and send gNB setup response message to SMF through gRPC
     * 2nd time PDU session establish message
     */
    create_session_grpc_req_on_gnb_setup_rsp(
        &amf_smf_grpc_ies, imsi, smf_ctx->pdu_session_version);

  } else {
    // TODO: implement failure message from gNB. messagge to send to SMF
    OAILOG_DEBUG(
        LOG_AMF_APP, "" Failure message not handled and dropping the message\\n"");
  }
}

/* Handling Resource Release Response from gNB */
void amf_app_handle_resource_release_response(
    itti_ngap_pdusessionresource_rel_rsp_t session_rel_resp) {
  /*
   * Release request always should be successful.
   * This response message will be dropped here as nothing to do.
   * as pdu_session_resource_release_response_transfer is
   * optional as per 38.413 - 9.3.4.2.1
   */
  OAILOG_DEBUG(
      LOG_AMF_APP, "" handling uplink PDU session release response message\\n"");
  if (session_rel_resp.pduSessionResourceReleasedRspList.no_of_items > 0) {
    /* This is success case and we need not to send message to SMF
     * and drop the message here
     */
    OAILOG_DEBUG(
        LOG_AMF_APP,
        "" this is success case of release response and no need to ""
        ""hadle anything and drop the message\\n"");
  } else {
    // TODO implement failure message from gNB. messagge to send to SMF
    OAILOG_DEBUG(
        LOG_AMF_APP, "" Failure message not handled and dropping the message\\n"");
  }
}

/* This function gets invoked based on the message NGAP_UE_CONTEXT_RELEASE_REQ
 * from gNB/NGAP in UL for handling CM-idle state of UE/IMSI/SUPI.
 * Action logic:
 * - Fetch AMF context, match the no of PDU sessions in message with no of
 *   PDU sessions in AMF_context and cause NGAP_RADIO_NR_GENERATED_REASON
 *   it means gNB RRC-Inactive triggered and UE state must be changed from
 *   CM-connected to CM-Idle state.
 *   Then send message to SMF to change all respective PDU session state
 *   to inactive state.
 * - Retrieve the required field of UE, like IMSI and fill gRPC notification
 *   proto structure.
 * - In AMF move the UE/IMSI state to CM-idle
 *   Go over all PDU sessions and change the state to in-active.
 * */
void amf_app_handle_cm_idle_on_ue_context_release(
    itti_ngap_ue_context_release_req_t cm_idle_req) {
  int rc = RETURNerror;
  OAILOG_DEBUG(
      LOG_AMF_APP,
      "" Handling UL UE context release for CM-idle for UE ""
      ""ID: "" AMF_UE_NGAP_ID_FMT,
      cm_idle_req.amf_ue_ngap_id);
  /* Currently only one PDU session is considered.
   * for multiple PDU session context (smf_context_t) will be part of vector
   * and no. of PDU sessions can be derived from this vector and compared
   * with NGAP message in future.
   * Now only need to check the cause and proceed further.
   * note: check if UE in connected state else already in idle state
   * nothing to do.
   */
  amf_ue_ngap_id_t ue_id;
  ue_m5gmm_context_s* ue_context = nullptr;
  ue_id                          = cm_idle_req.amf_ue_ngap_id;

  ue_context = amf_ue_context_exists_amf_ue_ngap_id(ue_id);
  if (!ue_context) {
    return;
  }

  // if UE on REGISTERED_IDLE, so no need to do anyting
  if ((ue_context->mm_state == REGISTERED_CONNECTED) ||
      (ue_context->mm_state == DEREGISTERED)) {
    // UE in connected state and need to check if cause is proper
    if (cm_idle_req.relCause == NGAP_RADIO_NR_GENERATED_REASON) {
      rc = ue_state_handle_message_initial(
          ue_context->mm_state, STATE_EVENT_CONTEXT_RELEASE, SESSION_NULL,
          ue_context, &ue_context->amf_context);

      if (rc != RETURNok) {
        OAILOG_WARNING(LOG_AMF_APP, ""Failed transitioning to idle mode\\n"");
      }

      ue_context_release_command(
          ue_id, ue_context->gnb_ue_ngap_id, NGAP_USER_INACTIVITY);
      ue_context->gnb_ngap_id_key = INVALID_GNB_UE_NGAP_ID_KEY;

    } else {
      OAILOG_WARNING(
          LOG_AMF_APP,
          "" UE in registered_connected state, but cause from NGAP""
          "" is wrong for UE ID: "" AMF_UE_NGAP_ID_FMT "" and return"",
          cm_idle_req.amf_ue_ngap_id);
      return;
    }
  } else {
    /* TODO: Single or multiple PDU session state change notification
     * should be taken care here. amf_smf_notification_send will be used
     * with one more parameter as boolean for idle mode or single PDU
     * session state change. Currently nothing to do
     */
    OAILOG_DEBUG(
        LOG_AMF_APP,
        "" UE in REGISTERED_IDLE or CM-idle state, nothing to do""
        "" for UE ID: "" AMF_UE_NGAP_ID_FMT,
        cm_idle_req.amf_ue_ngap_id);
    return;
  }
}

/* Routine to send ue context release command to NGAP after processing
 * ue context release request from NGAP. this command will change ue
 * state to idle.
 */
void ue_context_release_command(
    amf_ue_ngap_id_t amf_ue_ngap_id, gnb_ue_ngap_id_t gnb_ue_ngap_id,
    Ngcause ng_cause) {
  OAILOG_FUNC_IN(LOG_AMF_APP);
  itti_ngap_ue_context_release_command_t* ctx_rel_cmd = nullptr;
  MessageDef* message_p                               = nullptr;

  OAILOG_DEBUG(
      LOG_AMF_APP,
      ""preparing for context release command to NGAP ""
      ""for ue_id "" AMF_UE_NGAP_ID_FMT,
      amf_ue_ngap_id);

  message_p =
      itti_alloc_new_message(TASK_AMF_APP, NGAP_UE_CONTEXT_RELEASE_COMMAND);
  ctx_rel_cmd = &message_p->ittiMsg.ngap_ue_context_release_command;
  memset(ctx_rel_cmd, 0, sizeof(itti_ngap_ue_context_release_command_t));
  // Filling the respective values of NGAP message
  ctx_rel_cmd->amf_ue_ngap_id = amf_ue_ngap_id;
  ctx_rel_cmd->gnb_ue_ngap_id = gnb_ue_ngap_id;
  ctx_rel_cmd->cause          = ng_cause;
  // Send message to NGAP task
  amf_send_msg_to_task(&amf_app_task_zmq_ctx, TASK_NGAP, message_p);
  OAILOG_FUNC_OUT(LOG_AMF_APP);
}

static int paging_t3513_handler(zloop_t* loop, int timer_id, void* arg) {
  OAILOG_INFO(LOG_AMF_APP, ""T3513: In Paging handler\\n"");
  int rc                                         = RETURNerror;
  amf_ue_ngap_id_t ue_id                         = 0;
  ue_m5gmm_context_s* ue_context                 = nullptr;
  amf_context_t* amf_ctx                         = nullptr;
  paging_context_t* paging_ctx                   = nullptr;
  MessageDef* message_p                          = nullptr;
  itti_ngap_paging_request_t* ngap_paging_notify = nullptr;

  if (!amf_app_get_timer_arg(timer_id, &ue_id)) {
    OAILOG_WARNING(
        LOG_AMF_APP, ""T3513: Invalid Timer Id expiration, Timer Id: %u\\n"",
        timer_id);
    OAILOG_FUNC_RETURN(LOG_NAS_AMF, RETURNok);
  }

  ue_context = amf_ue_context_exists_amf_ue_ngap_id(ue_id);

  if (ue_context == NULL) {
    OAILOG_INFO(LOG_AMF_APP, ""ue_context is NULL\\n"");
    OAILOG_FUNC_RETURN(LOG_NAS_AMF, RETURNok);
  }

  // Get Paging Context
  amf_ctx    = &ue_context->amf_context;
  paging_ctx = &ue_context->paging_context;

  paging_ctx->m5_paging_response_timer.id = NAS5G_TIMER_INACTIVE_ID;

  if (paging_ctx->paging_retx_count < MAX_PAGING_RETRY_COUNT) {
    paging_ctx->paging_retx_count += 1;

    OAILOG_DEBUG(
        LOG_AMF_APP,
        ""T3513: timer has expired for UE ID: "" AMF_UE_NGAP_ID_FMT
        "" with timer id: %d, Sending Paging request again"",
        ue_id, timer_id);
    /*
     * Increment the retransmission counter
     */
    OAILOG_DEBUG(
        LOG_AMF_APP, ""T3513: Incrementing retransmission_count to %d\\n"",
        paging_ctx->paging_retx_count);

    /*
     * ReSend Paging request message to the UE
     */

    // Fill the itti msg based on context info produced in amf core

    message_p = itti_alloc_new_message(TASK_AMF_APP, NGAP_PAGING_REQUEST);

    ngap_paging_notify = &message_p->ittiMsg.ngap_paging_request;
    memset(ngap_paging_notify, 0, sizeof(itti_ngap_paging_request_t));
    ngap_paging_notify->UEPagingIdentity.amf_set_id =
        amf_ctx->m5_guti.guamfi.amf_set_id;
    ngap_paging_notify->UEPagingIdentity.amf_pointer =
        amf_ctx->m5_guti.guamfi.amf_pointer;
    OAILOG_DEBUG(
        LOG_AMF_APP,
        ""T3513: Filling NGAP structure for Downlink amf_ctx dec ""
        ""m_tmsi=%d"",
        amf_ctx->m5_guti.m_tmsi);
    ngap_paging_notify->UEPagingIdentity.m_tmsi = amf_ctx->m5_guti.m_tmsi;
    OAILOG_INFO(
        LOG_AMF_APP, ""T3513: Filling NGAP structure for Downlink m_tmsi=%d"",
        ngap_paging_notify->UEPagingIdentity.m_tmsi);
    ngap_paging_notify->TAIListForPaging.tai_list[0].plmn.mcc_digit1 =
        amf_ctx->m5_guti.guamfi.plmn.mcc_digit1;
    ngap_paging_notify->TAIListForPaging.tai_list[0].plmn.mcc_digit2 =
        amf_ctx->m5_guti.guamfi.plmn.mcc_digit2;
    ngap_paging_notify->TAIListForPaging.tai_list[0].plmn.mcc_digit3 =
        amf_ctx->m5_guti.guamfi.plmn.mcc_digit3;
    ngap_paging_notify->TAIListForPaging.tai_list[0].plmn.mnc_digit1 =
        amf_ctx->m5_guti.guamfi.plmn.mnc_digit1;
    ngap_paging_notify->TAIListForPaging.tai_list[0].plmn.mnc_digit2 =
        amf_ctx->m5_guti.guamfi.plmn.mnc_digit2;
    ngap_paging_notify->TAIListForPaging.tai_list[0].plmn.mnc_digit3 =
        amf_ctx->m5_guti.guamfi.plmn.mnc_digit3;
    ngap_paging_notify->TAIListForPaging.no_of_items     = 1;
    ngap_paging_notify->TAIListForPaging.tai_list[0].tac = 2;

    OAILOG_INFO(LOG_AMF_APP, ""T3513: sending downlink message to NGAP"");
    rc = send_msg_to_task(&amf_app_task_zmq_ctx, TASK_NGAP, message_p);
    if (rc != RETURNok)
      OAILOG_ERROR(LOG_AMF_APP, ""Could not send msg to task\\n"");
    //    amf_paging_request(paging_ctx);
  } else {
    /*
     * Abort the Paging procedure
     */
    OAILOG_ERROR(
        LOG_AMF_APP,
        ""T3513: Maximum retires done hence Abort the Paging Request ""
        ""procedure\\n"");
  }
  OAILOG_FUNC_RETURN(LOG_NAS_AMF, RETURNok);
}

// Doing Paging Request handling received from SMF in AMF CORE
// int amf_app_defs::amf_app_handle_notification_received(
int amf_app_handle_notification_received(
    itti_n11_received_notification_t* notification) {
  ue_m5gmm_context_s* ue_context                 = nullptr;
  amf_context_t* amf_ctx                         = nullptr;
  paging_context_t* paging_ctx                   = nullptr;
  MessageDef* message_p                          = nullptr;
  itti_ngap_paging_request_t* ngap_paging_notify = nullptr;
  int rc                                         = RETURNok;

  imsi64_t imsi64;
  IMSI_STRING_TO_IMSI64(notification->imsi, &imsi64);

  OAILOG_DEBUG(LOG_AMF_APP, ""IMSI is %s %lu\\n"", notification->imsi, imsi64);
  // Handle smf_context
  ue_context = lookup_ue_ctxt_by_imsi(imsi64);

  if (!ue_context) {
    OAILOG_ERROR(LOG_AMF_APP, ""UE context is null\\n"");
    return -1;
  }

  switch (notification->notify_ue_evnt) {
    case UE_PAGING_NOTIFY:
      OAILOG_DEBUG(LOG_AMF_APP, ""Paging notification received\\n"");

      // Get Paging Context
      amf_ctx    = &ue_context->amf_context;
      paging_ctx = &ue_context->paging_context;

      OAILOG_INFO(
          LOG_AMF_APP,
          ""T3513: Starting PAGING Timer for UE ID: "" AMF_UE_NGAP_ID_FMT,
          ue_context->amf_ue_ngap_id);
      paging_ctx->paging_retx_count = 0;
      /* Start Paging Timer T3513 */
      paging_ctx->m5_paging_response_timer.id = amf_app_start_timer(
          PAGING_TIMER_EXPIRY_MSECS, TIMER_REPEAT_ONCE, paging_t3513_handler,
          ue_context->amf_ue_ngap_id);
      // Fill the itti msg based on context info produced in amf core
      OAILOG_INFO(
          LOG_AMF_APP,
          ""T3513: Starting PAGING Timer for UE ID: "" AMF_UE_NGAP_ID_FMT
          "" and timer id: %ld"",
          ue_context->amf_ue_ngap_id, paging_ctx->m5_paging_response_timer.id);

      message_p = itti_alloc_new_message(TASK_AMF_APP, NGAP_PAGING_REQUEST);

      ngap_paging_notify = &message_p->ittiMsg.ngap_paging_request;
      memset(ngap_paging_notify, 0, sizeof(itti_ngap_paging_request_t));
      ngap_paging_notify->UEPagingIdentity.amf_set_id =
          amf_ctx->m5_guti.guamfi.amf_set_id;
      ngap_paging_notify->UEPagingIdentity.amf_pointer =
          amf_ctx->m5_guti.guamfi.amf_pointer;
      ngap_paging_notify->UEPagingIdentity.m_tmsi = amf_ctx->m5_guti.m_tmsi;
      ngap_paging_notify->TAIListForPaging.tai_list[0].plmn.mcc_digit1 =
          amf_ctx->m5_guti.guamfi.plmn.mcc_digit1;
      ngap_paging_notify->TAIListForPaging.tai_list[0].plmn.mcc_digit2 =
          amf_ctx->m5_guti.guamfi.plmn.mcc_digit2;
      ngap_paging_notify->TAIListForPaging.tai_list[0].plmn.mcc_digit3 =
          amf_ctx->m5_guti.guamfi.plmn.mcc_digit3;
      ngap_paging_notify->TAIListForPaging.tai_list[0].plmn.mnc_digit1 =
          amf_ctx->m5_guti.guamfi.plmn.mnc_digit1;
      ngap_paging_notify->TAIListForPaging.tai_list[0].plmn.mnc_digit2 =
          amf_ctx->m5_guti.guamfi.plmn.mnc_digit2;
      ngap_paging_notify->TAIListForPaging.tai_list[0].plmn.mnc_digit3 =
          amf_ctx->m5_guti.guamfi.plmn.mnc_digit3;
      ngap_paging_notify->TAIListForPaging.no_of_items     = 1;
      ngap_paging_notify->TAIListForPaging.tai_list[0].tac = 2;
      OAILOG_INFO(LOG_AMF_APP, ""AMF_APP: sending downlink message to NGAP"");
      rc = send_msg_to_task(&amf_app_task_zmq_ctx, TASK_NGAP, message_p);
      break;

    case UE_SERVICE_REQUEST_ON_PAGING:
      OAILOG_DEBUG(LOG_AMF_APP, ""Service Accept notification received\\n"");
      // TODO: Service Accept code to be implemented in upcoming PR
    default:
      OAILOG_DEBUG(LOG_AMF_APP, ""default case nothing to do\\n"");
      break;
  }
  OAILOG_FUNC_RETURN(LOG_NAS_AMF, rc);
}

void amf_app_handle_initial_context_setup_rsp(
    amf_app_desc_t* amf_app_desc_p,
    itti_amf_app_initial_context_setup_rsp_t* initial_context_rsp) {
  ue_m5gmm_context_s* ue_context = NULL;
  std::shared_ptr<smf_context_t> smf_context;
  char imsi[IMSI_BCD_DIGITS_MAX + 1];
  Ngap_PDUSession_Resource_Setup_Response_List_t* pdu_list =
      &initial_context_rsp->PDU_Session_Resource_Setup_Response_Transfer;

  // Handle smf_context
  ue_context = amf_ue_context_exists_amf_ue_ngap_id(initial_context_rsp->ue_id);

  // s6a update location request
  int rc = amf_send_n11_update_location_req(ue_context->amf_ue_ngap_id);

  if (rc == RETURNerror) {
    OAILOG_INFO(LOG_AMF_APP, ""AMF_APP: n11_update_location_req failure\\n"");
  }

  if (!ue_context) {
    OAILOG_ERROR(
        LOG_AMF_APP, "" Ue context not found for the id "" AMF_UE_NGAP_ID_FMT,
        initial_context_rsp->ue_id);
    return;
  }

  /* activating pdu sessions when UE is in IDLE state  */
  if (pdu_list->no_of_items) {
    for (uint32_t index = 0; index < pdu_list->no_of_items; index++) {
      smf_context = amf_get_smf_context_by_pdu_session_id(
          ue_context, pdu_list->item[index].Pdu_Session_ID);
      if (smf_context == NULL) {
        OAILOG_ERROR(
            LOG_AMF_APP, ""pdu session  not found for session_id = %ld\\n"",
            pdu_list->item[index].Pdu_Session_ID);
      } else {
        amf_smf_establish_t amf_smf_grpc_ies;

        // gnb tunnel info

        smf_context->gtp_tunnel_id.gnb_gtp_teid =
            htonl(*(reinterpret_cast<unsigned int*>(
                pdu_list->item[index]
                    .PDU_Session_Resource_Setup_Response_Transfer.tunnel
                    .gTP_TEID)));
        memcpy(
            smf_context->gtp_tunnel_id.gnb_gtp_teid_ip_addr,
            pdu_list->item[index]
                .PDU_Session_Resource_Setup_Response_Transfer.tunnel
                .transportLayerAddress,
            4);

        OAILOG_DEBUG(
            LOG_AMF_APP,
            ""IP address %02x %02x %02x %02x  and TEID"" GNB_GTP_TEID_FMT ""\\n"",
            smf_context->gtp_tunnel_id.gnb_gtp_teid_ip_addr[0],
            smf_context->gtp_tunnel_id.gnb_gtp_teid_ip_addr[1],
            smf_context->gtp_tunnel_id.gnb_gtp_teid_ip_addr[2],
            smf_context->gtp_tunnel_id.gnb_gtp_teid_ip_addr[3],
            smf_context->gtp_tunnel_id.gnb_gtp_teid);

        smf_context->pdu_session_version++;
        /*Copy respective gNB fields to amf_smf_establish_t compartible to gRPC
         * message*/
        memset(
            &amf_smf_grpc_ies.gnb_gtp_teid_ip_addr, '\\0',
            sizeof(amf_smf_grpc_ies.gnb_gtp_teid_ip_addr));
        memset(
            &amf_smf_grpc_ies.gnb_gtp_teid, '\\0',
            sizeof(amf_smf_grpc_ies.gnb_gtp_teid));
        memcpy(
            &amf_smf_grpc_ies.gnb_gtp_teid_ip_addr,
            &smf_context->gtp_tunnel_id.gnb_gtp_teid_ip_addr, 4);
        memcpy(
            &amf_smf_grpc_ies.gnb_gtp_teid,
            &smf_context->gtp_tunnel_id.gnb_gtp_teid, 4);
        amf_smf_grpc_ies.pdu_session_id = pdu_list->item[index].Pdu_Session_ID;

        IMSI64_TO_STRING(ue_context->amf_context.imsi64, imsi, 15);
        /* Prepare and send gNB setup response message to SMF through gRPC
         * 2nd time PDU session establish message
         */
        create_session_grpc_req_on_gnb_setup_rsp(
            &amf_smf_grpc_ies, imsi, smf_context->pdu_session_version);
      }
    }
  }

  // update UE state
  ue_context->mm_state = REGISTERED_CONNECTED;
}
}  // namespace magma5g
",16192,True,2831.058542308633,median
"ifdef::env-github[]
NOTE: Release notes are best read in our documentation at
https://www.elastic.co/guide/en/apm/agent/java/current/release-notes.html[elastic.co]
endif::[]

////
[[release-notes-x.x.x]]
==== x.x.x - YYYY/MM/DD

[float]
===== Breaking changes

[float]
===== Features
* Cool new feature: {pull}2526[#2526]

[float]
===== Bug fixes
////

=== Unreleased

[[release-notes-1.18.0]]
==== 1.18.0 - YYYY/MM/DD

[float]
===== Breaking changes

[float]
===== Features
* Experimental support for runtime attachment now also for OSGi containers, JBoss, and WildFly
* New mitigation of OSGi bootdelegation errors (`NoClassDefFoundError`).
  You can remove any `org.osgi.framework.bootdelegation` related configuration.
  This release also removes the configuration option `boot_delegation_packages`.
* Overhaul of the `ExecutorService` instrumentation that avoids `ClassCastException` issues - {pull}1206[#1206]
* Support for `ForkJoinPool` and `ScheduledExecutorService` (see <<supported-async-frameworks>>)
* Support for `ExecutorService#invokeAny` and `ExecutorService#invokeAll`
* Added support for `java.util.TimerTask` - {pull}1235[#1235]
* Add capturing of request body in Elasticsearch queries: `_msearch`, `_count`, `_msearch/template`, `_search/template`, `_rollup_search` - {pull}1222[#1222]
* Add <<config-enabled,`enabled`>> flag
* Add experimental support for Scala Futures
* The agent now collects heap memory pools metrics - {pull}1228[#1228]
* Deprecating `ignore_urls` config in favour of <<config-transaction-ignore-urls, `transaction_ignore_urls`>> to align
  with other agents, while still allowing the old config name for backward compatibility - {pull}1315[#1315]
* Enabling instrumentation of classes compiled with Java 1.4. This is reverting the restriction of instrumenting only
  bytecode of Java 1.5 or higher ({pull}320[#320]), which was added due to potential `VerifyError`. Such errors should be
  avoided now by the usage of `TypeConstantAdjustment` - {pull}1317[#1317]
* Enabling agent to work without attempting any communication with APM server, by allowing setting `server_urls` with
  an empty string - {pull}1295[#1295]
* Add <<metrics-micrometer, micrometer support>> - {pull}1303[#1303]

[float]
===== Bug fixes
* Fixes error capturing for log4j2 loggers. Version 1.17.0 introduced a regression.
* Fixes `NullPointerException` related to JAX-RS and Quartz instrumentation - {pull}1249[#1249]
* Expanding k8s pod ID discovery to some formerly non-supported environments
* When `recording` is set to `false`, the agent will not send captured errors anymore.
* Fixes NPE in Dubbo instrumentation that occurs when the application is acting both as a provider and as a consumer - {pull}1260[#1260]
* Adding a delay by default what attaching the agent to Tomcat using the premain route to work around the JUL
  deadlock issue - {pull}1262[#1262]
* Fixes missing `jboss.as:*` MBeans on JBoss - {pull}1257[#1257]
* Fixes a `NoClassDefFoundError` in the JMS instrumentation of `MessageListener` - {pull}1287[#1287]
* Fix `/ by zero` error message when setting `server_urls` with an empty string - {pull}1295[#1295]
* Fix `ClassNotFoundException` or `ClassCastException` in some cases where special log4j configurations are used - {pull}1322[#1322]
* Fix `NumberFormatException` when using early access Java version - {pull}1325[#1325]
* Fix `service_name` config being ignored when set to the same auto-discovered default value - {pull}1324[#1324]
* Fix service name error when updating a web app on a Servlet container - {pull}1326[#1326]

[[release-notes-1.x]]
=== Java Agent version 1.x

[[release-notes-1.18.0.rc1]]
==== 1.18.0.RC1 - 2020/07/22

This release candidate adds some highly anticipated features:
It’s now possible to attach the agent at runtime in more cases than before.
Most notably, it enables runtime attachment on JBoss, WildFly, Glassfish/Payara,
and other OSGi runtimes such as Atlassian Jira and Confluence.

To make this and other significant features, such as https://github.com/elastic/apm-agent-java/issues/937[external plugins], possible,
we have implemented major changes to the architecture of the agent.
The agent now relies on the `invokedynamic` bytecode instruction to make plugin development easier, safer, and more efficient.
As early versions of Java 7 and Java 8 have unreliable support for invokedynamic,
we now require a minimum update level of 60 for Java 7 (7u60+) in addition to the existing minimum update level of 40 for Java 8 (8u40+).

We’re looking for users who would like to try this out to give feedback.
If we see that the `invokedynamic`-based approach (https://github.com/elastic/apm-agent-java/pull/1230[indy plugins]) works well, we can continue and migrate the rest of the plugins.
After the migration has completed, we can move forward with external plugins and remove the experimental label from runtime attachment.

If all works like in our testing, you would not see `NoClassDefFoundError` s anymore when, for example, trying to attach the agent at runtime to an OSGi container or a JBoss server.
Also, non-standard OSGi containers, such as Atlassian Jira and other technologies with restrictive class loading policies, such as MuleSoft ESB, will benefit from this change.

In the worst case, there might be JVM crashes due to `invokedynamic`-related JVM bugs.
However, we already disable the agent when attached to JVM versions that are known to be problematic.
Another potentially problematic area is that we now dynamically raise the bytecode version of instrumented classes to be at least bytecode version 51 (Java 7).
This is needed in order to be able to use the `invokedynamic` instruction.
This requires re-computation of stack map frames which makes instrumentation a bit slower.
We don't anticipate notable slowdowns unless you extensively (over-)use <<config-trace-methods, `trace_methods`>>.

[float]
===== Breaking changes
* Early Java 7 versions, prior to update 60, are not supported anymore.
  When trying to attach to a non-supported version, the agent will disable itself and not apply any instrumentations.

[float]
===== Features
* Experimental support for runtime attachment now also for OSGi containers, JBoss, and WildFly
* New mitigation of OSGi bootdelegation errors (`NoClassDefFoundError`).
  You can remove any `org.osgi.framework.bootdelegation` related configuration.
  This release also removes the configuration option `boot_delegation_packages`.
* Overhaul of the `ExecutorService` instrumentation that avoids `ClassCastException` issues - {pull}1206[#1206]
* Support for `ForkJoinPool` and `ScheduledExecutorService` (see <<supported-async-frameworks>>)
* Support for `ExecutorService#invokeAny` and `ExecutorService#invokeAll`
* Added support for `java.util.TimerTask` - {pull}1235[#1235]
* Add capturing of request body in Elasticsearch queries: `_msearch`, `_count`, `_msearch/template`, `_search/template`, `_rollup_search` - {pull}1222[#1222]
* Add <<config-enabled,`enabled`>> flag
* Add experimental support for Scala Futures
* The agent now collects heap memory pools metrics - {pull}1228[#1228]

[float]
===== Bug fixes
* Fixes error capturing for log4j2 loggers. Version 1.17.0 introduced a regression.
* Fixes `NullPointerException` related to JAX-RS and Quartz instrumentation - {pull}1249[#1249]
* Expanding k8s pod ID discovery to some formerly non-supported environments
* When `recording` is set to `false`, the agent will not send captured errors anymore.
* Fixes NPE in Dubbo instrumentation that occurs when the application is acting both as a provider and as a consumer - {pull}1260[#1260]
* Adding a delay by default what attaching the agent to Tomcat using the premain route to work around the JUL
  deadlock issue - {pull}1262[#1262]
* Fixes missing `jboss.as:*` MBeans on JBoss - {pull}1257[#1257]


[[release-notes-1.17.0]]
==== 1.17.0 - 2020/06/17

[float]
===== Features
* Log files are now rotated after they reach <<config-log-file-size>>.
There will always be one history file `${log_file}.1`.
* Add <<config-log-format-sout>> and <<config-log-format-file>> with the options `PLAIN_TEXT` and `JSON`.
The latter uses https://github.com/elastic/ecs-logging-java[ecs-logging-java] to format the logs.
* Exposing <<config-classes-excluded-from-instrumentation>> config - {pull}1187[#1187]
* Add support for naming transactions based on Grails controllers. Supports Grails 3+ - {pull}1171[#1171]
* Add support for the Apache/Alibaba Dubbo RPC framework
* Async Profiler version upgraded to 1.7.1, with a new debugging flag for the stack frame recovery mechanism - {pull}1173[#1173]

[float]
===== Bug fixes
* Fixes `IndexOutOfBoundsException` that can occur when profiler-inferred spans are enabled.
  This also makes the profiler more resilient by just removing the call tree related to the exception (which might be in an invalid state)
  as opposed to stopping the profiler when an exception occurs.
* Fix `NumberFormatException` when parsing Ingres/Actian JDBC connection strings - {pull}1198[#1198]
* Prevent agent from overriding JVM configured truststore when not using HTTPS for communication with APM server - {pull}1203[#1203]
* Fix `java.lang.IllegalStateException` with `jps` JVM when using continuous runtime attach - {pull}1205[1205]
* Fix agent trying to load log4j2 plugins from application - {pull}1214[1214]
* Fix memory leak in gRPC instrumentation plugin - {pull}1196[1196]
* Fix HTTPS connection failures when agent is configured to use HTTPS to communicate with APM server {pull}1209[1209]

[[release-notes-1.16.0]]
==== 1.16.0 - 2020/05/13

[float]
===== Features

* The log correlation feature now adds `error.id` to the MDC. See <<supported-logging-frameworks>> for details. - {pull}1050[#1050]
* Deprecating the `incubating` tag in favour of the `experimental` tag. This is not a breaking change, so former
<<config-disable-instrumentations,`disable_instrumentation`>> configuration containing the `incubating` tag will still be respected - {pull}1123[#1123]
* Add a `--without-emulated-attach` option for runtime attachment to allow disabling this feature as a workaround.
* Add workaround for JDK bug JDK-8236039 with TLS 1.3 {pull}1149[#1149]
* Add log level `OFF` to silence agent logging
* Adds <<config-span-min-duration,`span_min_duration`>> option to exclude fast executing spans.
  When set together with one of the more specific thresholds - `trace_methods_duration_threshold` or `profiling_inferred_spans_min_duration`,
  the higher threshold will determine which spans will be discarded.
* Automatically instrument quartz jobs from the quartz-jobs artifact {pull}1170[#1170]
* Perform re-parenting of regular spans to be a child of profiler-inferred spans. Requires APM Server and Kibana 7.8.0. {pull}1117[#1117]
* Upgrade Async Profiler version to 1.7.0

[float]
===== Bug fixes

* When Servlet-related Exceptions are handled through exception handlers that return a 200 status code, agent shouldn't override with 500 - {pull}1103[#1103]
* Exclude Quartz 1 from instrumentation to avoid
  `IncompatibleClassChangeError: Found class org.quartz.JobExecutionContext, but interface was expected` - {pull}1108[#1108]
* Fix breakdown metrics span sub-types {pull}1113[#1113]
* Fix flaky gRPC server instrumentation {pull}1122[#1122]
* Fix side effect of calling `Statement.getUpdateCount` more than once {pull}1139[#1139]
* Stop capturing JDBC affected rows count using `Statement.getUpdateCount` to prevent unreliable side-effects {pull}1147[#1147]
* Fix OpenTracing error tag handling (set transaction error result when tag value is `true`) {pull}1159[#1159]
* Due to a bug in the build we didn't include the gRPC plugin in the build so far
* `java.lang.ClassNotFoundException: Unable to load class 'jdk.internal...'` is thrown when tracing specific versions of Atlassian systems {pull}1168[#1168]
* Make sure spans are kept active during `AsyncHandler` methods in the `AsyncHttpClient`
* CPU and memory metrics are sometimes not reported properly when using IBM J9 {pull}1148[#1148]
* `NullPointerException` thrown by the agent on WebLogic {pull}1142[#1142]

[[release-notes-1.15.0]]
==== 1.15.0 - 2020/03/27

[float]
===== Breaking changes

* Ordering of configuration sources has slightly changed, please review <<configuration>>:
** `elasticapm.properties` file now has higher priority over java system properties and environment variables, +
This change allows to change dynamic options values at runtime by editing file, previously values set in java properties
or environment variables could not be overridden, even if they were dynamic.
* Renamed some configuration options related to the experimental profiler-inferred spans feature ({pull}1084[#1084]):
** `profiling_spans_enabled` -> `profiling_inferred_spans_enabled`
** `profiling_sampling_interval` -> `profiling_inferred_spans_sampling_interval`
** `profiling_spans_min_duration` -> `profiling_inferred_spans_min_duration`
** `profiling_included_classes` -> `profiling_inferred_spans_included_classes`
** `profiling_excluded_classes` -> `profiling_inferred_spans_excluded_classes`
** Removed `profiling_interval` and `profiling_duration` (both are fixed to 5s now)

[float]
===== Features

* Gracefully abort agent init when running on a known Java 8 buggy JVM {pull}1075[#1075].
* Add support for <<supported-databases, Redis Redisson client>>
* Makes <<config-instrument>>, <<config-trace-methods>>, and <<config-disable-instrumentations>> dynamic.
Note that changing these values at runtime can slow down the application temporarily.
* Do not instrument Servlet API before 3.0 {pull}1077[#1077]
* Add support for API keys for apm backend authentication {pull}1083[#1083]
* Add support for <<supported-rpc-frameworks, gRPC>> client & server instrumentation {pull}1019[#1019]
* Deprecating `active` configuration option in favor of `recording`.
  Setting `active` still works as it's now an alias for `recording`.

[float]
===== Bug fixes

* When JAX-RS-annotated method delegates to another JAX-RS-annotated method, transaction name should include method A - {pull}1062[#1062]
* Fixed bug that prevented an APM Error from being created when calling `org.slf4j.Logger#error` - {pull}1049[#1049]
* Wrong address in JDBC spans for Oracle, MySQL and MariaDB when multiple hosts are configured - {pull}1082[#1082]
* Document and re-order configuration priorities {pull}1087[#1087]
* Improve heuristic for `service_name` when not set through config {pull}1097[#1097]


[[release-notes-1.14.0]]
==== 1.14.0 - 2020/03/04

[float]
===== Features

* Support for the official https://www.w3.org/TR/trace-context[W3C] `traceparent` and `tracestate` headers. +
  The agent now accepts both the `elastic-apm-traceparent` and the official `traceparent` header.
By default, it sends both headers on outgoing requests, unless <<config-use-elastic-traceparent-header, `use_elastic_traceparent_header`>> is set to false.
* Creating spans for slow methods with the help of the sampling profiler https://github.com/jvm-profiling-tools/async-profiler[async-profiler].
This is a low-overhead way of seeing which methods make your transactions slow and a replacement for the `trace_methods` configuration option.
See <<supported-java-methods>> for more details
* Adding a Circuit Breaker to pause the agent when stress is detected on the system and resume when the stress is relieved.
See <<circuit-breaker>> and {pull}1040[#1040] for more info.
* `Span#captureException` and `Transaction#captureException` in public API return reported error id - {pull}1015[#1015]

[float]
===== Bug fixes

* java.lang.IllegalStateException: Cannot resolve type description for <com.another.commercial.apm.agent.Class> - {pull}1037[#1037]
* properly handle `java.sql.SQLException` for unsupported JDBC features {pull}[#1035] https://github.com/elastic/apm-agent-java/issues/1025[#1025]

[[release-notes-1.13.0]]
==== 1.13.0 - 2020/02/11

[float]
===== Features

* Add support for <<supported-databases, Redis Lettuce client>>
* Add `context.message.age.ms` field for JMS message receiving spans and transactions - {pull}970[#970]
* Instrument log4j2 Logger#error(String, Throwable) ({pull}919[#919]) Automatically captures exceptions when calling `logger.error(""message"", exception)`
* Add instrumentation for external process execution through `java.lang.Process` and Apache `commons-exec` - {pull}903[#903]
* Add `destination` fields to exit span contexts - {pull}976[#976]
* Removed `context.message.topic.name` field - {pull}993[#993]
* Add support for Kafka clients - {pull}981[#981]
* Add support for binary `traceparent` header format (see the https://github.com/elastic/apm/blob/master/docs/agent-development.md#Binary-Fields[spec]
for more details) - {pull}1009[#1009]
* Add support for log correlation for log4j and log4j2, even when not used in combination with slf4j.
  See <<supported-logging-frameworks>> for details.

[float]
===== Bug Fixes

* Fix parsing value of `trace_methods` configuration property {pull}930[#930]
* Workaround for `java.util.logging` deadlock {pull}965[#965]
* JMS should propagate traceparent header when transactions are not sampled {pull}999[#999]
* Spans are not closed if JDBC implementation does not support `getUpdateCount` {pull}1008[#1008]

[[release-notes-1.12.0]]
==== 1.12.0 - 2019/11/21

[float]
===== Features
* JMS Enhancements {pull}911[#911]:
** Add special handling for temporary queues/topics
** Capture message bodies of text Messages
*** Rely on the existing `ELASTIC_APM_CAPTURE_BODY` agent config option (off by default).
*** Send as `context.message.body`
*** Limit size to 10000 characters. If longer than this size, trim to 9999 and append with ellipsis
** Introduce the `ignore_message_queues` configuration to disable instrumentation (message tagging) for specific 
      queues/topics as suggested in {pull}710[#710]
** Capture predefined message headers and all properties
*** Rely on the existing `ELASTIC_APM_CAPTURE_HEADERS` agent config option.
*** Send as `context.message.headers`
*** Sanitize sensitive headers/properties based on the `sanitize_field_names` config option
* Added support for the MongoDB sync driver. See https://www.elastic.co/guide/en/apm/agent/java/master/supported-technologies-details.html#supported-databases[supported data stores].

[float]
===== Bug Fixes
* JDBC regression- `PreparedStatement#executeUpdate()` and `PreparedStatement#executeLargeUpdate()` are not traced {pull}918[#918]
* When systemd cgroup driver is used, the discovered Kubernetes pod UID contains ""_"" instead of ""-"" {pull}920[#920]
* DB2 jcc4 driver is not traced properly {pull}926[#926]

[[release-notes-1.11.0]]
==== 1.11.0 - 2019/10/31

[float]
===== Features
* Add the ability to configure a unique name for a JVM within a service through the
https://www.elastic.co/guide/en/apm/agent/java/master/config-core.html#config-service-node-name[`service_node_name`]
config option]
* Add ability to ignore some exceptions to be reported as errors https://www.elastic.co/guide/en/apm/agent/java/master/config-core.html#config-ignore-exceptions[ignore_exceptions]
* Applying new logic for JMS `javax.jms.MessageConsumer#receive` so that, instead of the transaction created for the 
   polling method itself (ie from `receive` start to end), the agent will create a transaction attempting to capture 
   the code executed during actual message handling.
   This logic is suitable for environments where polling APIs are invoked within dedicated polling threads.
   This polling transaction creation strategy can be reversed through a configuration option (`message_polling_transaction_strategy`) 
   that is not exposed in the properties file by default.  
* Send IP obtained through `javax.servlet.ServletRequest#getRemoteAddr()` in `context.request.socket.remote_address` 
   instead of parsing from headers {pull}889[#889]
* Added `ElasticApmAttacher.attach(String propertiesLocation)` to specify a custom properties location
* Logs message when `transaction_max_spans` has been exceeded {pull}849[#849]
* Report the number of affected rows by a SQL statement (UPDATE,DELETE,INSERT) in 'affected_rows' span attribute {pull}707[#707]
* Add https://www.elastic.co/guide/en/apm/agent/java/master/public-api.html#api-traced[`@Traced`] annotation which either creates a span or a transaction, depending on the context
* Report JMS destination as a span/transaction context field {pull}906[#906]
* Added https://www.elastic.co/guide/en/apm/agent/java/master/config-jmx.html#config-capture-jmx-metrics[`capture_jmx_metrics`] configuration option

[float]
===== Bug Fixes
* JMS creates polling transactions even when the API invocations return without a message
* Support registering MBeans which are added after agent startup

[[release-notes-1.10.0]]
==== 1.10.0 - 2019/09/30

[float]
===== Features
* Add ability to manually specify reported https://www.elastic.co/guide/en/apm/agent/java/master/config-core.html#config-hostname[hostname]
* Add support for https://www.elastic.co/guide/en/apm/agent/java/master/supported-technologies-details.html#supported-databases[Redis Jedis client]
* Add support for identifying target JVM to attach apm agent to using JVM property. See also the documentation of the https://www.elastic.co/guide/en/apm/agent/java/master/setup-attach-cli.html#setup-attach-cli-usage-list[`--include` and `--exclude` flags]
* Added https://www.elastic.co/guide/en/apm/agent/java/master/config-jmx.html#config-capture-jmx-metrics[`capture_jmx_metrics`] configuration option
* Improve servlet error capture {pull}812[#812]
  Among others, now also takes Spring MVC `@ExceptionHandler`s into account 
* Instrument Logger#error(String, Throwable) {pull}821[#821]
  Automatically captures exceptions when calling `logger.error(""message"", exception)`
* Easier log correlation with https://github.com/elastic/java-ecs-logging. See https://www.elastic.co/guide/en/apm/agent/java/master/log-correlation.html[docs].
* Avoid creating a temp agent file for each attachment {pull}859[#859]
* Instrument `View#render` instead of `DispatcherServlet#render` {pull}829[#829]
  This makes the transaction breakdown graph more useful. Instead of `dispatcher-servlet`, the graph now shows a type which is based on the view name, for example, `FreeMarker` or `Thymeleaf`.

[float]
===== Bug Fixes
* Error in log when setting https://www.elastic.co/guide/en/apm/agent/java/current/config-reporter.html#config-server-urls[server_urls] 
 to an empty string - `co.elastic.apm.agent.configuration.ApmServerConfigurationSource - Expected previousException not to be null`
* Avoid terminating the TCP connection to APM Server when polling for configuration updates {pull}823[#823]
 
[[release-notes-1.9.0]]
==== 1.9.0 - 2019/08/22

[float]
===== Features
* Upgrading supported OpenTracing version from 0.31 to 0.33
* Added annotation and meta-annotation matching support for `trace_methods`, for example:
** `public @java.inject.* org.example.*` (for annotation)
** `public @@javax.enterprise.context.NormalScope org.example.*` (for meta-annotation)
* The runtime attachment now also works when the `tools.jar` or the `jdk.attach` module is not available.
This means you don't need a full JDK installation - the JRE is sufficient.
This makes the runtime attachment work in more environments such as minimal Docker containers.
Note that the runtime attachment currently does not work for OSGi containers like those used in many application servers such as JBoss and WildFly.
See the https://www.elastic.co/guide/en/apm/agent/java/master/setup-attach-cli.html[documentation] for more information.
* Support for Hibernate Search

[float]
===== Bug Fixes
* A warning in logs saying APM server is not available when using 1.8 with APM server 6.x.
Due to that, agent 1.8.0 will silently ignore non-string labels, even if used with APM server of versions 6.7.x or 6.8.x that support such.
If APM server version is <6.7 or 7.0+, this should have no effect. Otherwise, upgrade the Java agent to 1.9.0+.
* `ApacheHttpAsyncClientInstrumentation` matching increases startup time considerably
* Log correlation feature is active when `active==false`
* Tomcat's memory leak prevention mechanism is causing a... memory leak. JDBC statement map is leaking in Tomcat if the application that first used it is undeployed/redeployed.
See https://discuss.elastic.co/t/elastic-apm-agent-jdbchelper-seems-to-use-a-lot-of-memory/195295[this related discussion].

[float]
==== Breaking Changes
* The `apm-agent-attach.jar` is not executable anymore.
Use `apm-agent-attach-standalone.jar` instead. 

[[release-notes-1.8.0]]
==== 1.8.0 - 2019/07/30

[float]
===== Features
* Added support for tracking https://www.elastic.co/guide/en/kibana/7.3/transactions.html[time spent by span type].
   Can be disabled by setting https://www.elastic.co/guide/en/apm/agent/java/current/config-core.html#config-breakdown-metrics[`breakdown_metrics`] to `false`. 
* Added support for https://www.elastic.co/guide/en/kibana/7.3/agent-configuration.html[central configuration].
   Can be disabled by setting https://www.elastic.co/guide/en/apm/agent/java/current/config-core.html#config-central-config[`central_config`] to `false`.
* Added support for Spring's JMS flavor - instrumenting `org.springframework.jms.listener.SessionAwareMessageListener`
* Added support to legacy ApacheHttpClient APIs (which adds support to Axis2 configured to use ApacheHttpClient)
* Added support for setting https://www.elastic.co/guide/en/apm/agent/java/1.x/config-reporter.html#config-server-urls[`server_urls`] dynamically via properties file {pull}723[#723]
* Added https://www.elastic.co/guide/en/apm/agent/java/current/config-core.html#config-config-file[`config_file`] option 
* Added option to use `@javax.ws.rs.Path` value as transaction name https://www.elastic.co/guide/en/apm/agent/java/current/config-jax-rs.html#config-use-jaxrs-path-as-transaction-name[`use_jaxrs_path_as_transaction_name`]
* Instrument quartz jobs https://www.elastic.co/guide/en/apm/agent/java/current/supported-technologies-details.html#supported-scheduling-frameworks[docs]
* SQL parsing improvements {pull}696[#696]
* Introduce priorities for transaction name {pull}748[#748].
   Now uses the path as transaction name if https://www.elastic.co/guide/en/apm/agent/java/current/config-http.html#config-use-path-as-transaction-name[`use_path_as_transaction_name`] is set to `true`
   rather than `ServletClass#doGet`.
   But if a name can be determined from a high level framework,
   like Spring MVC, that takes precedence.
   User-supplied names from the API always take precedence over any others.
* Use JSP path name as transaction name as opposed to the generated servlet class name {pull}751[#751]

[float]
===== Bug Fixes
* Some JMS Consumers and Producers are filtered due to class name filtering in instrumentation matching
* Jetty: When no display name is set and context path is ""/"" transaction service names will now correctly fall back to configured values
* JDBC's `executeBatch` is not traced
* Drops non-String labels when connected to APM Server < 6.7 to avoid validation errors {pull}687[#687]
* Parsing container ID in cloud foundry garden {pull}695[#695]
* Automatic instrumentation should not override manual results {pull}752[#752]

[float]
===== Breaking changes
* The log correlation feature does not add `span.id` to the MDC anymore but only `trace.id` and `transaction.id` {pull}742[#742].

[[release-notes-1.7.0]]
==== 1.7.0 - 2019/06/13

[float]
===== Features
* Added the `trace_methods_duration_threshold` config option. When using the `trace_methods` config option with wild cards,
this enables considerable reduction of overhead by limiting the number of spans captured and reported
(see more details in config documentation).
NOTE: Using wildcards is still not the recommended approach for the `trace_methods` feature.
* Add `Transaction#addCustomContext(String key, String|Number|boolean value)` to public API
* Added support for AsyncHttpClient 2.x
* Added https://www.elastic.co/guide/en/apm/agent/java/current/config-core.html#config-global-labels[`global_labels`] configuration option.
This requires APM Server 7.2+.
* Added basic support for JMS- distributed tracing for basic scenarios of `send`, `receive`, `receiveNoWait` and `onMessage`.
Both Queues and Topics are supported.
Async `send` APIs are not supported in this version. 
NOTE: This feature is currently marked as ""experimental"" and is disabled by default. In order to enable,
it is required to set the
https://www.elastic.co/guide/en/apm/agent/java/1.x/config-core.html#config-disable-instrumentations[`disable_instrumentations`] 
configuration property to an empty string.
* Improved OSGi support: added a configuration option for `bootdelegation` packages {pull}641[#641]
* Better span names for SQL spans. For example, `SELECT FROM user` instead of just `SELECT` {pull}633[#633]

[float]
===== Bug Fixes
* ClassCastException related to async instrumentation of Pilotfish Executor causing thread hang (applied workaround)
* NullPointerException when computing Servlet transaction name with null HTTP method name
* FileNotFoundException when trying to find implementation version of jar with encoded URL
* NullPointerException when closing Apache AsyncHttpClient request producer
* Fixes loading of `elasticapm.properties` for Spring Boot applications
* Fix startup error on WebLogic 12.2.1.2.0 {pull}649[#649]
* Disable metrics reporting and APM Server health check when active=false {pull}653[#653]

[[release-notes-1.6.1]]
==== 1.6.1 - 2019/04/26

[float]
===== Bug Fixes
* Fixes transaction name for non-sampled transactions https://github.com/elastic/apm-agent-java/issues/581[#581]
* Makes log_file option work again https://github.com/elastic/apm-agent-java/issues/594[#594]
* Async context propagation fixes
** Fixing some async mechanisms lifecycle issues https://github.com/elastic/apm-agent-java/issues/605[#605]
** Fixes exceptions when using WildFly managed executor services https://github.com/elastic/apm-agent-java/issues/589[#589]
** Exclude glassfish Executor which does not permit wrapped runnables https://github.com/elastic/apm-agent-java/issues/596[#596]
** Exclude DumbExecutor https://github.com/elastic/apm-agent-java/issues/598[#598]
* Fixes Manifest version reading error to support `jar:file` protocol https://github.com/elastic/apm-agent-java/issues/601[#601]
* Fixes transaction name for non-sampled transactions https://github.com/elastic/apm-agent-java/issues/597[#597]
* Fixes potential classloader deadlock by preloading `FileSystems.getDefault()` https://github.com/elastic/apm-agent-java/issues/603[#603]

[[release-notes-1.6.0]]
==== 1.6.0 - 2019/04/16

[float]
===== Related Announcements
* Java APM Agent became part of the Cloud Foundry Java Buildpack as of https://github.com/cloudfoundry/java-buildpack/releases/tag/v4.19[Release v4.19]
 
[float]
===== Features
* Support Apache HttpAsyncClient - span creation and cross-service trace context propagation
* Added the `jvm.thread.count` metric, indicating the number of live threads in the JVM (daemon and non-daemon) 
* Added support for WebLogic
* Added support for Spring `@Scheduled` and EJB `@Schedule` annotations - https://github.com/elastic/apm-agent-java/pull/569[#569]

[float]
===== Bug Fixes
* Avoid that the agent blocks server shutdown in case the APM Server is not available - https://github.com/elastic/apm-agent-java/pull/554[#554]
* Public API annotations improper retention prevents it from being used with Groovy - https://github.com/elastic/apm-agent-java/pull/567[#567]
* Eliminate side effects of class loading related to Instrumentation matching mechanism

[[release-notes-1.5.0]]
==== 1.5.0 - 2019/03/26

[float]
===== Potentially breaking changes
* If you didn't explicitly set the https://www.elastic.co/guide/en/apm/agent/java/master/config-core.html#config-service-name[`service_name`]
previously and you are dealing with a servlet-based application (including Spring Boot),
your `service_name` will change.
See the documentation for https://www.elastic.co/guide/en/apm/agent/java/master/config-core.html#config-service-name[`service_name`]
and the corresponding section in _Features_ for more information.
Note: this requires APM Server 7.0+. If using previous versions, nothing will change.

[float]
===== Features
* Added property `""allow_path_on_hierarchy""` to JAX-RS plugin, to lookup inherited usage of `@path`
* Support for number and boolean labels in the public API {pull}497[497].
This change also renames `tag` to `label` on the API level to be compliant with the https://github.com/elastic/ecs#-base-fields[Elastic Common Schema (ECS)].
The `addTag(String, String)` method is still supported but deprecated in favor of `addLabel(String, String)`.
As of version 7.x of the stack, labels will be stored under `labels` in Elasticsearch.
Previously, they were stored under `context.tags`.
* Support async queries made by Elasticsearch REST client 
* Added `setStartTimestamp(long epochMicros)` and `end(long epochMicros)` API methods to `Span` and `Transaction`,
allowing to set custom start and end timestamps.
* Auto-detection of the `service_name` based on the `<display-name>` element of the `web.xml` with a fallback to the servlet context path.
If you are using a spring-based application, the agent will use the setting for `spring.application.name` for its `service_name`.
See the documentation for https://www.elastic.co/guide/en/apm/agent/java/master/config-core.html#config-service-name[`service_name`]
for more information.
Note: this requires APM Server 7.0+. If using previous versions, nothing will change.
* Previously, enabling https://www.elastic.co/guide/en/apm/agent/java/master/config-core.html#config-capture-body[`capture_body`] could only capture form parameters.
Now it supports all UTF-8 encoded plain-text content types.
The option https://www.elastic.co/guide/en/apm/agent/java/master/config-http.html#config-capture-body-content-types[`capture_body_content_types`]
controls which `Content-Type`s should be captured.
* Support async calls made by OkHttp client (`Call#enqueue`)
* Added support for providing config options on agent attach.
** CLI example: `--config server_urls=http://localhost:8200,http://localhost:8201`
** API example: `ElasticApmAttacher.attach(Map.of(""server_urls"", ""http://localhost:8200,http://localhost:8201""));`

[float]
===== Bug Fixes
* Logging integration through MDC is not working properly - https://github.com/elastic/apm-agent-java/issues/499[#499]
* ClassCastException with adoptopenjdk/openjdk11-openj9 - https://github.com/elastic/apm-agent-java/issues/505[#505]
* Span count limitation is not working properly - reported https://discuss.elastic.co/t/kibana-apm-not-showing-spans-which-are-visible-in-discover-too-many-spans/171690[in our forum]
* Java agent causes Exceptions in Alfresco cluster environment due to failure in the instrumentation of Hazelcast `Executor`s - reported https://discuss.elastic.co/t/cant-run-apm-java-agent-in-alfresco-cluster-environment/172962[in our forum]

[[release-notes-1.4.0]]
==== 1.4.0 - 2019/02/14

[float]
===== Features
* Added support for sync calls of OkHttp client
* Added support for context propagation for `java.util.concurrent.ExecutorService`s
* The `trace_methods` configuration now allows to omit the method matcher.
   Example: `com.example.*` traces all classes and methods within the `com.example` package and sub-packages.
* Added support for JSF. Tested on WildFly, WebSphere Liberty and Payara with embedded JSF implementation and on Tomcat and Jetty with
 MyFaces 2.2 and 2.3
* Introduces a new configuration option `disable_metrics` which disables the collection of metrics via a wildcard expression.
* Support for HttpUrlConnection
* Adds `subtype` and `action` to spans. This replaces former typing mechanism where type, subtype and action were all set through
   the type in an hierarchical dotted-syntax. In order to support existing API usages, dotted types are parsed into subtype and action, 
   however `Span.createSpan` and `Span.setType` are deprecated starting this version. Instead, type-less spans can be created using the new 
   `Span.startSpan` API and typed spans can be created using the new `Span.startSpan(String type, String subtype, String action)` API
* Support for JBoss EAP 6.4, 7.0, 7.1 and 7.2
* Improved startup times
* Support for SOAP (JAX-WS).
   SOAP client create spans and propagate context.
   Transactions are created for `@WebService` classes and `@WebMethod` methods.  

[float]
===== Bug Fixes
* Fixes a failure in BitBucket when agent deployed https://github.com/elastic/apm-agent-java/issues/349[#349]
* Fixes increased CPU consumption https://github.com/elastic/apm-agent-java/issues/453[#453] and https://github.com/elastic/apm-agent-java/issues/443[#443]
* Fixed some OpenTracing bridge functionalities that were not working when auto-instrumentation is disabled
* Fixed an error occurring when ending an OpenTracing span before deactivating
* Sending proper `null` for metrics that have a NaN value
* Fixes JVM crash with Java 7 https://github.com/elastic/apm-agent-java/issues/458[#458]
* Fixes an application deployment failure when using EclipseLink and `trace_methods` configuration https://github.com/elastic/apm-agent-java/issues/474[#474]

[[release-notes-1.3.0]]
==== 1.3.0 - 2019/01/10

[float]
===== Features
* The agent now collects system and JVM metrics https://github.com/elastic/apm-agent-java/pull/360[#360]
* Add API methods `ElasticApm#startTransactionWithRemoteParent` and `Span#injectTraceHeaders` to allow for manual context propagation https://github.com/elastic/apm-agent-java/pull/396[#396].
* Added `trace_methods` configuration option which lets you define which methods in your project or 3rd party libraries should be traced.
   To create spans for all `public` methods of classes whose name ends in `Service` which are in a sub-package of `org.example.services` use this matcher:
   `public org.example.services.*.*Service#*` https://github.com/elastic/apm-agent-java/pull/398[#398]
* Added span for `DispatcherServlet#render` https://github.com/elastic/apm-agent-java/pull/409[#409].
* Flush reporter on shutdown to make sure all recorded Spans are sent to the server before the program exits https://github.com/elastic/apm-agent-java/pull/397[#397]
* Adds Kubernetes https://github.com/elastic/apm-agent-java/issues/383[#383] and Docker metadata to, enabling correlation with the Kibana Infra UI.
* Improved error handling of the Servlet Async API https://github.com/elastic/apm-agent-java/issues/399[#399]
* Support async API’s used with AsyncContext.start https://github.com/elastic/apm-agent-java/issues/388[#388]

[float]
===== Bug Fixes
* Fixing a potential memory leak when there is no connection with APM server
* Fixes NoSuchMethodError CharBuffer.flip() which occurs when using the Elasticsearch RestClient and Java 7 or 8 https://github.com/elastic/apm-agent-java/pull/401[#401]

 
[[release-notes-1.2.0]]
==== 1.2.0 - 2018/12/19

[float]
===== Features
* Added `capture_headers` configuration option.
   Set to `false` to disable capturing request and response headers.
   This will reduce the allocation rate of the agent and can save you network bandwidth and disk space.
* Makes the API methods `addTag`, `setName`, `setType`, `setUser` and `setResult` fluent, so that calls can be chained. 

[float]
===== Bug Fixes
* Catch all errors thrown within agent injected code
* Enable public APIs and OpenTracing bridge to work properly in OSGi systems, fixes https://github.com/elastic/apm-agent-java/issues/362[this WildFly issue]
* Remove module-info.java to enable agent working on early Tomcat 8.5 versions
* Fix https://github.com/elastic/apm-agent-java/issues/371[async Servlet API issue]

[[release-notes-1.1.0]]
==== 1.1.0 - 2018/11/28

[float]
===== Features
* Some memory allocation improvements
* Enabling bootdelegation for agent classes in Atlassian OSGI systems

[float]
===== Bug Fixes
* Update dsl-json which fixes a memory leak.
 See https://github.com/ngs-doo/dsl-json/pull/102[ngs-doo/dsl-json#102] for details. 
* Avoid `VerifyError`s by non instrumenting classes compiled for Java 4 or earlier
* Enable APM Server URL configuration with path (fixes #339)
* Reverse `system.hostname` and `system.platform` order sent to APM server

[[release-notes-1.0.1]]
==== 1.0.1 - 2018/11/15

[float]
===== Bug Fixes
* Fixes NoSuchMethodError CharBuffer.flip() which occurs when using the Elasticsearch RestClient and Java 7 or 8 {pull}313[#313]

[[release-notes-1.0.0]]
==== 1.0.0 - 2018/11/14

[float]
===== Breaking changes
* Remove intake v1 support. This version requires APM Server 6.5.0+ which supports the intake api v2.
   Until the time the APM Server 6.5.0 is officially released,
   you can test with docker by pulling the APM Server image via
   `docker pull docker.elastic.co/apm/apm-server:6.5.0-SNAPSHOT`. 

[float]
===== Features
* Adds `@CaptureTransaction` and `@CaptureSpan` annotations which let you declaratively add custom transactions and spans.
   Note that it is required to configure the `application_packages` for this to work.
   See the https://www.elastic.co/guide/en/apm/agent/java/master/public-api.html#api-annotation[documentation] for more information.
* The public API now supports to activate a span on the current thread.
   This makes the span available via `ElasticApm#currentSpan()`
   Refer to the https://www.elastic.co/guide/en/apm/agent/java/master/public-api.html#api-span-activate[documentation] for more details.
* Capturing of Elasticsearch RestClient 5.0.2+ calls.
   Currently, the `*Async` methods are not supported, only their synchronous counterparts.
* Added API methods to enable correlating the spans created from the JavaScrip Real User Monitoring agent with the Java agent transaction.
   More information can be found in the https://www.elastic.co/guide/en/apm/agent/java/master/public-api.html#api-ensure-parent-id[documentation].
* Added `Transaction.isSampled()` and `Span.isSampled()` methods to the public API
* Added `Transaction#setResult` to the public API {pull}293[#293]

[float]
===== Bug Fixes
* Fix for situations where status code is reported as `200`, even though it actually was `500` {pull}225[#225]
* Capturing the username now properly works when using Spring security {pull}183[#183]

[[release-notes-1.0.0.rc1]]
==== 1.0.0.RC1 - 2018/11/06

[float]
===== Breaking changes
* Remove intake v1 support. This version requires APM Server 6.5.0+ which supports the intake api v2.
   Until the time the APM Server 6.5.0 is officially released,
   you can test with docker by pulling the APM Server image via
   `docker pull docker.elastic.co/apm/apm-server:6.5.0-SNAPSHOT`.
* Wildcard patterns are case insensitive by default. Prepend `(?-i)` to make the matching case sensitive.

[float]
===== Features
* Support for Distributed Tracing
* Adds `@CaptureTransaction` and `@CaptureSpan` annotations which let you declaratively add custom transactions and spans.
   Note that it is required to configure the `application_packages` for this to work.
   See the https://www.elastic.co/guide/en/apm/agent/java/master/public-api.html#api-annotation[documentation] for more information.
* The public API now supports to activate a span on the current thread.
   This makes the span available via `ElasticApm#currentSpan()`
   Refer to the https://www.elastic.co/guide/en/apm/agent/java/master/public-api.html#api-span-activate[documentation] for more details.
* Capturing of Elasticsearch RestClient 5.0.2+ calls.
   Currently, the `*Async` methods are not supported, only their synchronous counterparts.
* Added API methods to enable correlating the spans created from the JavaScrip Real User Monitoring agent with the Java agent transaction.
   More information can be found in the https://www.elastic.co/guide/en/apm/agent/java/master/public-api.html#api-ensure-parent-id[documentation].
* Microsecond accurate timestamps {pull}261[#261]
* Support for JAX-RS annotations.
Transactions are named based on your resources (`ResourceClass#resourceMethod`).

[float]
===== Bug Fixes
* Fix for situations where status code is reported as `200`, even though it actually was `500` {pull}225[#225]

[[release-notes-0.8.x]]
=== Java Agent version 0.8.x

[[release-notes-0.8.0]]
==== 0.8.0

[float]
===== Breaking changes
* Wildcard patterns are case insensitive by default. Prepend `(?-i)` to make the matching case sensitive.

[float]
===== Features
* Wildcard patterns are now not limited to only one wildcard in the middle and can be arbitrarily complex now.
   Example: `*foo*bar*baz`.
* Support for JAX-RS annotations.
   Transactions are named based on your resources (`ResourceClass#resourceMethod`).

[[release-notes-0.7.x]]
=== Java Agent version 0.7.x

[[release-notes-0.7.1]]
==== 0.7.1 - 2018/10/24

[float]
===== Bug Fixes
* Avoid recycling transactions twice {pull}178[#178]

[[release-notes-0.7.0]]
==== 0.7.0 - 2018/09/12

[float]
===== Breaking changes
* Removed `ElasticApm.startSpan`. Spans can now only be created from their transactions via `Transaction#createSpan`.
* `ElasticApm.startTransaction` and `Transaction#createSpan` don't activate the transaction and spans
   and are thus not available via `ElasticApm.activeTransaction` and `ElasticApm.activeSpan`.

[float]
===== Features
* Public API
** Add `Span#captureException` and `Transaction#captureException` to public API.
      `ElasticApm.captureException` is deprecated now. Use `ElasticApm.currentSpan().captureException(exception)` instead.
** Added `Transaction.getId` and `Span.getId` methods 
* Added support for async servlet requests
* Added support for Payara/Glassfish
* Incubating support for Apache HttpClient
* Support for Spring RestTemplate
* Added configuration options `use_path_as_transaction_name` and `url_groups`,
   which allow to use the URL path as the transaction name.
   As that could contain path parameters, like `/user/$userId` however,
   You can set the `url_groups` option to define a wildcard pattern, like `/user/*`,
   to group those paths together.
   This is especially helpful when using an unsupported Servlet API-based framework. 
* Support duration suffixes (`ms`, `s` and `m`) for duration configuration options.
   Not using the duration suffix logs out a deprecation warning and will not be supported in future versions.
* Add ability to add multiple APM server URLs, which enables client-side load balancing.
   The configuration option `server_url` has been renamed to `server_urls` to reflect this change.
   However, `server_url` still works for backwards compatibility.
* The configuration option `service_name` is now optional.
   It defaults to the main class name,
   the name of the executed jar file (removing the version number),
   or the application server name (for example `tomcat-application`).
   In a lot of cases,
   you will still want to set the `service_name` explicitly.
   But it helps getting started and seeing data easier,
   as there are no required configuration options anymore.
   In the future we will most likely determine more useful application names for Servlet API-based applications.
",12211,True,2540.8923460401465,median
"//===- Fusion.cpp - Implementation of linalg Fusion -----------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements the linalg dialect Fusion on tensors operations pass.
//
//===----------------------------------------------------------------------===//
#include ""PassDetail.h""
#include ""mlir/Dialect/Affine/IR/AffineOps.h""
#include ""mlir/Dialect/Linalg/IR/LinalgOps.h""
#include ""mlir/Dialect/Linalg/IR/LinalgTypes.h""
#include ""mlir/Dialect/Linalg/Passes.h""
#include ""mlir/Dialect/Linalg/Transforms/Transforms.h""
#include ""mlir/Dialect/Linalg/Utils/Utils.h""
#include ""mlir/IR/AffineExpr.h""
#include ""mlir/IR/AffineMap.h""
#include ""mlir/IR/PatternMatch.h""
#include ""mlir/Support/LLVM.h""
#include ""mlir/Transforms/GreedyPatternRewriteDriver.h""

using namespace mlir;
using namespace mlir::linalg;

/// Implementation of fusion of generic ops and indexed_generic ops.
static bool areElementwiseOpsFusable(LinalgOp producer, LinalgOp consumer,
                                     unsigned consumerIdx) {
  // Producer and consumer must have tensor semantics.
  if (!producer.hasTensorSemantics() || !consumer.hasTensorSemantics())
    return false;

  // Verify that
  // - the producer has all ""parallel"" iterator type.
  if (producer.getNumParallelLoops() != producer.getNumLoops())
    return false;

  // Only allow fusing the producer of an input operand for now.
  // TODO: allow fusing the producer of an output operand.
  if (consumerIdx >= consumer.getNumInputs())
    return false;

  // Get the consumer index map. The number of results of the consumer index
  // map must match the number of loops of the producer.
  AffineMap consumerIndexMap = consumer.getIndexingMap(consumerIdx);
  if (consumerIndexMap.getNumResults() != producer.getNumLoops())
    return false;

  // Currently support only operations with single result.
  if (producer.getNumOutputs() != 1)
    return false;

  // Finally the index_map for the result must be invertible. For now just
  // verify it is a permutation.
  AffineMap producerResultIndexMap = producer.getOutputIndexingMap(0);
  return producerResultIndexMap.isPermutation();
}

/// Append to `fusedOpIndexingMapAttrs` the indexing maps for the operands of
/// the `producer` to use in the fused operation given the indexing map of the
/// result of the producer in the consumer.
static AffineMap getIndexingMapOfProducerOperandsInCoordinatesOfFusedOp(
    OpOperand &producerOpOperand, AffineMap producerResultIndexMap,
    AffineMap fusedConsumerArgIndexMap) {
  // The indexing map in the consumer op (fusedConsumerArgIndexMap) is a map
  // from consumer loop -> consumer arg tensor index/producer result tensor
  // index. The fused loop is same as the consumer loop. For each producer arg
  // the indexing map to be computed is a map from consumer loop -> producer
  // arg tensor index.
  // producerResultIndexMap is a map from producer loop -> tensor index.
  // Compute the inverse to get map from tensor index -> producer loop.
  // The inverse is a map from producer result tensor index -> producer loop.
  AffineMap invProducerResultIndexMap =
      inversePermutation(producerResultIndexMap);
  assert(invProducerResultIndexMap &&
         ""expected producer result indexig map to be invertible"");

  LinalgOp producer = cast<LinalgOp>(producerOpOperand.getOwner());
  // argMap is a map from producer loop -> producer arg tensor index.
  AffineMap argMap =
      producer.getIndexingMap(producerOpOperand.getOperandNumber());

  // Compose argMap with invProducerResultIndexMap to get a map from
  // producer result tensor index -> producer arg tensor index.
  AffineMap t1 = argMap.compose(invProducerResultIndexMap);

  // Compose t1 with fusedConsumerArgIndexMap gives an indexing map from
  // consumer loop/ fused loop -> producer arg tensor index.
  return t1.compose(fusedConsumerArgIndexMap);
}

/// Generate the region of the fused tensor operation. The region of the fused
/// op must be empty.
static void
generateFusedElementwiseOpRegion(PatternRewriter &rewriter, Operation *fusedOp,
                                 LinalgOp producer, LinalgOp consumer,
                                 AffineMap consumerToProducerLoopsMap,
                                 unsigned consumerIdx, unsigned nloops) {
  // Build the region of the fused op.
  Block &producerBlock = producer->getRegion(0).front();
  Block &consumerBlock = consumer->getRegion(0).front();
  Block *fusedBlock = new Block();
  fusedOp->getRegion(0).push_back(fusedBlock);
  BlockAndValueMapping mapper;
  OpBuilder::InsertionGuard guard(rewriter);
  rewriter.setInsertionPointToStart(fusedBlock);

  // The block arguments are
  // [index_0, index_1, ... ,
  //   consumer_operand_0, ... , consumer_operand_(`consumerIdx`-1),
  //   producer_operand_0, ... , producer_operand_(n-1)],
  //   consumer_operand_(`consumerIdx`), .. consumer_operand_(m-1)]
  // , where n is the number of producer's operand and m is the number
  // consumer's operand.
  // If both `numProducerIndices` and `numConsumerIndices` are zero, this is a
  // generic op. In this case, there are no indices in block arguments.
  unsigned numProducerIndices = isa<IndexedGenericOp>(producer.getOperation())
                                    ? producer.getNumLoops()
                                    : 0;
  unsigned numConsumerIndices = isa<IndexedGenericOp>(consumer.getOperation())
                                    ? consumer.getNumLoops()
                                    : 0;
  unsigned numFusedOpIndices =
      (isa<IndexedGenericOp>(producer.getOperation()) ||
       isa<IndexedGenericOp>(consumer.getOperation()))
          ? std::max(producer.getNumLoops(), consumer.getNumLoops())
          : 0;

  // 0. Firstly, add all the indices to the block arguments.
  for (unsigned i = 0, e = numFusedOpIndices; i < e; ++i)
    fusedBlock->addArgument(rewriter.getIndexType());
  // 1. Map consumer indices to fusedBlock indices 1-1.
  mapper.map(consumerBlock.getArguments().take_front(numConsumerIndices),
             fusedBlock->getArguments().take_front(numConsumerIndices));
  // 2a. Embed producer indices into fusedBlock index space 1-1.
  for (auto it :
       llvm::zip(producerBlock.getArguments().take_front(numProducerIndices),
                 fusedBlock->getArguments().take_front(numProducerIndices))) {
    auto newIndex = rewriter.create<mlir::AffineApplyOp>(
        producer.getLoc(),
        consumerToProducerLoopsMap.getSubMap(std::get<0>(it).getArgNumber()),
        fusedBlock->getArguments().take_front(numFusedOpIndices));
    mapper.map(std::get<0>(it), newIndex);
  }
  // 2b. Replace the producer index operations by index operations placed in the
  // fused block using the `consumerToProducerLoopsMap` to map the index spaces.
  unsigned numFusedOpLoops =
      std::max(producer.getNumLoops(), consumer.getNumLoops());
  if (producer.hasIndexSemantics()) {
    SmallVector<Value> fusedIndices;
    fusedIndices.reserve(numFusedOpLoops);
    llvm::transform(llvm::seq<int64_t>(0, numFusedOpLoops),
                    std::back_inserter(fusedIndices), [&](int64_t dim) {
                      return rewriter.create<IndexOp>(producer.getLoc(), dim);
                    });
    for (IndexOp indexOp :
         llvm::make_early_inc_range(producerBlock.getOps<IndexOp>())) {
      Value newIndex = rewriter.create<mlir::AffineApplyOp>(
          producer.getLoc(),
          consumerToProducerLoopsMap.getSubMap(indexOp.dim()), fusedIndices);
      // Replace the producer index operation by the index value computed in the
      // fused block. All remaining operations in the producer block are later
      // on cloned to the fused block.
      rewriter.replaceOp(indexOp, newIndex);
    }
  }
  // TODO: allow fusing the producer of an output operand.
  assert(consumerIdx < consumer.getNumInputs() &&
         ""expected producer of input operand"");
  // 3. Consumer input operands up to consumerIdx (exclusive).
  for (BlockArgument bbArg : consumerBlock.getArguments()
                                 .drop_front(numConsumerIndices)
                                 .take_front(consumerIdx)) // input assumption.
    mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType()));

  // Replacing consumerIdx requires getting the cloned, yielded, value from
  // the (cloned) producer block. This happens in step 9.

  // 4. Splice in producer's input operands.
  for (BlockArgument bbArg : producerBlock.getArguments()
                                 .drop_front(numProducerIndices)
                                 .take_front(producer.getNumInputs()))
    mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType()));

  // 4.b. Producer output operand/map that is fused needs to be mapped to the
  // producer bbArg if it is an ""initTensor"" (i.e. its value is actually read).
  assert(producer->getNumResults() == 1 && ""expected single result producer"");
  if (producer.isInitTensor(&producer.getOutputOpOperands()[0])) {
    BlockArgument bbArg =
        producerBlock.getArguments()
            .drop_front(numConsumerIndices + producer.getNumInputs())
            // TODO: bbArg index of
            .front();
    mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType()));
  }
  // 5. Remaining consumer's input operands (drop past index `consumerIdx`).
  for (BlockArgument bbArg : consumerBlock.getArguments()
                                 .drop_front(numConsumerIndices)
                                 .take_front(consumer.getNumInputs())
                                 .drop_front(consumerIdx + 1))
    mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType()));
  // 6. All of consumer's output operands.
  for (BlockArgument bbArg :
       consumerBlock.getArguments().take_back(consumer.getNumOutputs()))
    mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType()));
  // 7. All of producer's output operands except the one fused.
  // TODO: allow fusion of multi-result producers.
  assert(producer->getNumResults() == 1 && ""expected single result producer"");

  // 8. Clone operations from producer (except the yield operation) to the fused
  // op.
  for (auto &op : producerBlock.without_terminator())
    rewriter.clone(op, mapper);
  // 9. Now we can map the consumerBlock's `consumerIdx` block argument. Just
  // forward the yield operand.
  auto yieldOp = cast<linalg::YieldOp>(producerBlock.getTerminator());
  // TODO: allow fusion of multi-result producers.
  assert(producer->getNumResults() == 1 && ""expected single result producer"");
  unsigned producerResultNumber = 0;
  Value replacement =
      mapper.lookupOrDefault(yieldOp.getOperand(producerResultNumber));
  // Sanity checks, if replacement is not already in the mapper then it must be
  // produced outside.
  if (replacement == yieldOp.getOperand(producerResultNumber)) {
    if (auto bb = replacement.dyn_cast<BlockArgument>())
      assert(bb.getOwner() != &producerBlock &&
             ""yielded block argument must have been mapped"");
    else
      assert(!producer->isAncestor(replacement.getDefiningOp()) &&
             ""yielded value must have been mapped"");
  }
  mapper.map(consumerBlock.getArgument(consumerIdx + numConsumerIndices),
             replacement);
  // 10. Clone operations from the consumer to the fused op.
  for (auto &op : consumerBlock.getOperations())
    rewriter.clone(op, mapper);

  // Sanity checks.
  assert(fusedBlock->getNumArguments() ==
             fusedOp->getNumOperands() + numFusedOpIndices &&
         ""Ill-formed LinalgOp region"");
}

static Optional<SmallVector<Value, 1>>
fuseElementwiseOpsImpl(LinalgOp producer, OpOperand &consumerOpOperand,
                       const ControlElementwiseOpsFusionFn &controlFn,
                       PatternRewriter &rewriter) {
  LinalgOp consumer = cast<LinalgOp>(consumerOpOperand.getOwner());
  unsigned consumerIdx = consumerOpOperand.getOperandNumber();
  if (!areElementwiseOpsFusable(producer, consumer, consumerIdx) ||
      !controlFn(producer->getResult(0), consumerOpOperand))
    return llvm::None;

  // TODO: allow fusing the producer of an output operand.
  assert(consumerIdx < consumer.getNumInputs() &&
         ""expected producer of input operand"");

  // Compute the fused operands list and indexing maps.
  SmallVector<Value> fusedOperands;
  SmallVector<AffineMap> fusedIndexMaps;
  fusedOperands.reserve(producer->getNumOperands() +
                        consumer->getNumOperands());
  fusedIndexMaps.reserve(producer->getNumOperands() +
                         consumer->getNumOperands());
  // In the following, numbering matches that of `generateFusedTensorOpRegion`.
  // 3. Consumer input operands/maps up to consumerIdx (exclusive).
  llvm::append_range(fusedOperands,
                     consumer.getInputs().take_front(consumerIdx));
  llvm::append_range(
      fusedIndexMaps,
      ArrayRef<AffineMap>{consumer.getInputIndexingMaps()}.take_front(
          consumerIdx));
  // 4. Splice in producer's input operands/maps.
  llvm::append_range(fusedOperands, producer.getInputs());
  assert(producer->getNumResults() == 1 && ""expected single result producer"");
  AffineMap producerResultIndexMap = producer.getOutputIndexingMap(0);
  for (auto &inputOpOperand : producer.getInputOpOperands()) {
    // Compute indexing maps for the producer args in the fused operation.
    AffineMap map = getIndexingMapOfProducerOperandsInCoordinatesOfFusedOp(
        inputOpOperand, producerResultIndexMap,
        consumer.getInputIndexingMap(consumerIdx));
    fusedIndexMaps.push_back(map);
  }
  // 4.b. Producer output operand/map that is fused needs to be passed if it is
  // an ""initTensor"" (i.e. its value is actually read).
  assert(producer->getNumResults() == 1 && ""expected single result producer"");
  if (producer.isInitTensor(&producer.getOutputOpOperands()[0])) {
    llvm::append_range(fusedOperands, producer.getOutputs().take_front());
    // Compute indexing maps for the producer args in the fused operation.
    AffineMap map = getIndexingMapOfProducerOperandsInCoordinatesOfFusedOp(
        producer.getOutputOpOperands().front(), producerResultIndexMap,
        consumer.getOutputIndexingMap(0));
    fusedIndexMaps.push_back(map);
  }
  // 5. Remaining consumer's input operands/maps (drop past index
  // `consumerIdx`).
  llvm::append_range(fusedOperands,
                     consumer.getInputs().drop_front(consumerIdx + 1));
  llvm::append_range(
      fusedIndexMaps,
      ArrayRef<AffineMap>{consumer.getInputIndexingMaps()}.drop_front(
          consumerIdx + 1));
  // 6. All of consumer's output operands (skip operands: added by the builder).
  // llvm::append_range(fusedOperands, consumer.getOutputs());
  llvm::append_range(fusedIndexMaps, consumer.getOutputIndexingMaps());
  // 7. All of producer's output operands/maps except the one fused.
  // TODO: allow fusion of multi-result producers.
  assert(producer->getNumResults() == 1 && ""expected single result producer"");

  // Generate the fused op.
  Operation *fusedOp;
  if (isa<GenericOp>(producer.getOperation()) &&
      isa<GenericOp>(consumer.getOperation())) {
    fusedOp = rewriter.create<GenericOp>(
        consumer.getLoc(), consumer->getResultTypes(),
        /*inputs=*/fusedOperands,
        // TODO: handle outputs.
        consumer.getOutputs(), rewriter.getAffineMapArrayAttr(fusedIndexMaps),
        consumer.iterator_types(),
        /*doc=*/nullptr,
        /*library_call=*/nullptr,
        /*sparse=*/nullptr);
  } else {
    fusedOp = rewriter.create<IndexedGenericOp>(
        consumer.getLoc(), consumer->getResultTypes(),
        /*inputs=*/fusedOperands,
        // TODO: handle outputs.
        consumer.getOutputs(), rewriter.getAffineMapArrayAttr(fusedIndexMaps),
        consumer.iterator_types(),
        /*doc=*/nullptr,
        /*library_call=*/nullptr,
        /*sparse=*/nullptr);
  }

  // Construct an AffineMap from consumer loops to producer loops.
  // consumer loop -> tensor index
  AffineMap consumerResultIndexMap = consumer.getInputIndexingMap(consumerIdx);
  // tensor index -> producer loop
  AffineMap invProducerResultIndexMap =
      inversePermutation(producerResultIndexMap);
  assert(invProducerResultIndexMap &&
         ""expected producer result indexig map to be invertible"");
  // consumer loop -> producer loop
  AffineMap consumerToProducerLoopsMap =
      invProducerResultIndexMap.compose(consumerResultIndexMap);

  generateFusedElementwiseOpRegion(rewriter, fusedOp, producer, consumer,
                                   consumerToProducerLoopsMap, consumerIdx,
                                   consumer.getNumLoops());
  return SmallVector<Value, 1>(fusedOp->getResults());
}

/// Linearize the expressions in `sourceMap` based on the `reassociationMaps`
/// provided, given the shape of the source tensor that corresponds to the
/// `sourceMap`. Note that this implicitly assumes that the tensors dimensions
/// are ""row-major"" ordered logically.
///
/// For example:
///
/// %0 = op ... : tensor<?x?x4x5xf32>
/// with output index_map `affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>`
///
/// and reshape:
/// %1 = linalg.tensor_reshape %0 [affine_map<(i, j, k, l) -> (i)>,
///                                affine_map<(i, j, k, l) -> (j, k, l)>] :
///        tensor<?x?x4x5xf32> into tensor<?x?xf32>
///
/// would be rewritten into:
/// %0 = op ... : tensor<?x?x4x5xf32>
/// with output index_map
///   `affine_map<(d0, d1, d2, d3) -> (d0, d1 * 20 + d2 * 5 + d3)>`
static AffineMap linearizeCollapsedDims(AffineMap sourceMap,
                                        ArrayRef<int64_t> sourceShape,
                                        ArrayRef<AffineMap> reassociationMaps) {
  SmallVector<AffineExpr, 4> resultExprs;
  resultExprs.reserve(reassociationMaps.size());
  ArrayRef<AffineExpr> sourceExprs = sourceMap.getResults();
  MLIRContext *context = sourceMap.getContext();

  // Compute the result exprs based on the reassociation maps.
  for (AffineMap map : reassociationMaps) {
    ArrayRef<AffineExpr> collapsedDims = map.getResults();
    // Assume that they are in-order and contiguous (already checked in
    // verifier).
    assert(!collapsedDims.empty());
    unsigned startDim =
        collapsedDims.front().cast<AffineDimExpr>().getPosition();
    SmallVector<int64_t, 4> sizes;
    SmallVector<AffineExpr, 4> dimExprs;
    for (auto en :
         llvm::zip(sourceShape.slice(startDim, collapsedDims.size()),
                   sourceExprs.slice(startDim, collapsedDims.size()))) {
      if (std::get<0>(en) == 1)
        continue;
      sizes.push_back(std::get<0>(en));
      dimExprs.push_back(std::get<1>(en));
    }
    AffineExpr linearizedExpr =
        makeCanonicalStridedLayoutExpr(sizes, dimExprs, context);
    resultExprs.push_back(linearizedExpr);
  }
  return AffineMap::get(sourceMap.getNumDims(), sourceMap.getNumSymbols(),
                        resultExprs, context);
}

/// Checks if the `reshapeOp` can be fused with it consumer (if `asProducer` is
/// true) or its producer (if `asProducer` is false) given the indexing map at
/// its use.
static bool isTensorReshapeOpFoldableByLinearization(TensorReshapeOp reshapeOp,
                                                     AffineMap useIndexMap,
                                                     bool asProducer) {
  RankedTensorType returnType = reshapeOp.getResultType();
  RankedTensorType operandType = reshapeOp.getSrcType();
  // Reshape is fusable with its consumer (i.e. reshape as a producer) when its
  // operand is of lesser rank than the result. Fusing when operand has higher
  // rank will require use of mods and divs in the indexing maps of the fused op
  // which would make it non-invertible. Similarly reshape is fused with its
  // producer (i.e. reshape as consumer) only if the return type has lesser
  // rank.
  if ((asProducer && reshapeOp.getSrcType().hasStaticShape() &&
       returnType.getRank() < operandType.getRank()) ||
      (!asProducer && reshapeOp.getResultType().hasStaticShape() &&
       operandType.getRank() < returnType.getRank()))
    return false;
  return useIndexMap.isPermutation();
}

/// Based on the type of `op` create a linalg op of the same type, i.e. if `op`
/// is a linalg.generic operation, the create a `linalg.generic` operation with
/// the given `args`. Expects `op` to be `linalg.generic` or
/// `linalg.indexed_generic`.
template <typename... Args>
static LinalgOp createLinalgOpOfSameType(LinalgOp op, PatternRewriter &rewriter,
                                         Args... args) {
  if (isa<GenericOp>(op.getOperation()))
    return rewriter.create<GenericOp>(args...);
  if (isa<IndexedGenericOp>(op.getOperation()))
    return rewriter.create<IndexedGenericOp>(args...);
  llvm_unreachable(
      ""expected only linalg.generic or linalg.indexed_generic ops"");
  return nullptr;
}

/// Check if the reshape operation is only expansion into/collapsing of
/// unit-dimension.
static bool isUnitDimExpansionOnly(ArrayRef<int64_t> expandedShape,
                                   ArrayRef<AffineMap> reassociation) {
  for (auto &map : reassociation) {
    unsigned numUnitDims = 0;
    for (AffineExpr expr : map.getResults()) {
      unsigned position = expr.cast<AffineDimExpr>().getPosition();
      if (expandedShape[position] == 1)
        numUnitDims++;
    }
    if (numUnitDims != map.getNumResults() - 1)
      return false;
  }
  return true;
}

/// Conditions for folding a generic/indexed-generic operation with a reshape op
/// by expanding the iteration space dimensionality for tensor operations. These
/// are preconditions assumed by `foldReshapeByDimExpansion` which implements
/// the following fusion pattern.
///
///  Consider
///
///  %c = linalg.generic ins(%a, %b : memref<?x?x?xf32>, memref<?x?xf32>)
///         indexing_maps = [affine_map<(d0, d1, d2) -> (d1, d0, d2)>,
///                          affine_map<(d0, d1, d2) -> (d1, d2)>,
///                          affine_map<(d0, d1, d2) -> (d0, d2, d1)>]
///  %d = linalg.tensor_reshape %c
///         [affine_map<(d0, d1, d2, d3, d4, d5) -> (d0, d1)>,
///          affine_map<(d0, d1, d2, d3, d4, d5) -> (d2)>,
///          affine_map<(d0, d1, d2, d3, d4, d5) -> (d3, d4, d5)>]
///       : tensor<?x?x?xf32> into tensor<?x?x?x?x?x?xf32>
///
///  The reshape can be folded into the `linalgOp` if the
///  generic/indexed-generic op loop dimensionality is increased to match the
///  result (operand) of the tensor_reshape when the reshape is expanding
///  (folding). The indexing_map of the fused tensor in the `linalgOp` and the
///  reassociation map helps compute the indexing maps of the modified op. For
///  the above example, based on the reassociation map it can be concluded that
///
///  - The loop used to access the first dimension of the fused tensor is split
///    into two.
///  - The loop used to access the second dimension of the fused tensor is kept
///    as is.
///  - The loop used to access the third dimension of the fused tensor is split
///    into three.
///
///  i.e. (e0, e1, e2, e3, e4) is the domain of the indexing map of the modified
///  op, then
///
///   d0 -> e0, e1
///   d1 -> e2, e3, e4
///   d2 -> e5
///
///  substituting this, the generic op can be rewritten as
///
///  %d = linalg.generic ins(%0, %1 : )
///        indexing_maps =
///         [affine_map<(e0, e1, e2, e3, e4, e5) -> (e2, e3, e4, e0, e1, e5)>,
///          affine_map<(e0, e1, e2, e3, e4, e5) -> (e2, e3, e4, e5)>,
///          affine_map<(e0, e1, e2, e3, e4, e5) -> (e0, e1, e5, e2, e3, e4)>]
///
///  Since operands to the linalg generic are now 5D, reshapes can be introduced
///  to make it consistent
///
///  %0 = linalg.tensor_reshape %a
///         [affine_map<(e0, e1, e2, e3, e4, e5) -> (e0, e1, e2),
///          affine_map<(e0, e1, e2, e3, e4, e5) -> (e3, e4),
///          affine_map<(e0, e1, e2, e3, e4, e5) -> (e5)]
///       : tensor<?x?x?xf32> into tensor<?x?x?x?x?x?xf32>
///  %1 = linalg.tensor_reshape %b
///         [affine_map<(e0, e1, e2, e3) -> (e0, e1, e2),
///          affine_map<(e0, e1, e2, e3) -> (e3)]
///       : tensor<?x?x?xf32> into tensor<?x?x?x?xf32>
///
///  The added reshapes are again expanding patterns, so they will get fused
///  with its producers if possible.
static bool isFusableWithReshapeByDimExpansion(LinalgOp linalgOp,
                                               unsigned fusedTensorIndex) {
  // Is fusable only if:
  // - The linalgOp is a generic op, or an indexed_generic.
  // - All the indexing maps for operands and results in linalgOp are projected
  //   permutations.
  // - The fused tensor is not a scalar.
  // - All the loops in linalgOp are parallel loops.
  return isa<GenericOp, IndexedGenericOp>(linalgOp.getOperation()) &&
         linalgOp.hasTensorSemantics() &&
         llvm::all_of(linalgOp.indexing_maps().getValue(),
                      [](Attribute attr) {
                        return attr.cast<AffineMapAttr>()
                            .getValue()
                            .isProjectedPermutation();
                      }) &&
         linalgOp.getIndexingMap(fusedTensorIndex).getNumResults() > 0 &&
         llvm::all_of(linalgOp.iterator_types(), [](Attribute attr) {
           return attr.cast<StringAttr>().getValue() ==
                  getParallelIteratorTypeName();
         });
}

namespace {
/// Information needed to expand a generic/indexed_generic operation to fold the
/// reshape with it.
class ExpansionInfo {
public:
  // Computes the mapping from original dimensions of the op to the dimensions
  // of the expanded op given the `indexingMap` of the fused operand/result of
  // the generic/indexed_generic op, the `reassocationMaps` of the reshape op
  // and the shape of the expanded op.
  LogicalResult compute(LinalgOp linalgOp, unsigned fusedTensorIndex,
                        ArrayRef<AffineMap> reassociationMaps,
                        ArrayRef<int64_t> expandedShape);
  unsigned getOrigOpNumDims() const { return reassociation.size(); }
  unsigned getExpandedOpNumDims() const { return expandedOpNumDims; }
  ReassociationIndicesRef getExpandedDims(unsigned i) const {
    return reassociation[i];
  }
  ArrayRef<int64_t> getExpandedShapeOfDim(unsigned i) const {
    return expandedShapeMap[i];
  }

private:
  /// Reassociation from the dimensions in the original operation to the
  /// dimension of the expanded operation.
  SmallVector<ReassociationIndices, 4> reassociation;
  /// Mapping from extent of loops in the original operation, to the extent of
  /// loops in the expanded operation.
  SmallVector<SmallVector<int64_t, 4>, 4> expandedShapeMap;
  unsigned expandedOpNumDims;
};
} // namespace

LogicalResult ExpansionInfo::compute(LinalgOp linalgOp,
                                     unsigned fusedTensorIndex,
                                     ArrayRef<AffineMap> reassociationMaps,
                                     ArrayRef<int64_t> expandedShape) {
  if (reassociationMaps.empty())
    return failure();
  AffineMap fusedIndexMap = linalgOp.getIndexingMap(fusedTensorIndex);

  Optional<SmallVector<int64_t, 4>> originalLoopRange =
      linalgOp.getStaticLoopRanges();
  if (!originalLoopRange)
    return linalgOp.emitError(""unable to find loop range for operation"");

  reassociation.clear();
  expandedShapeMap.clear();
  // Compute the number of dimension in the expanded op that correspond to each
  // dimension of the original op.
  SmallVector<unsigned, 4> numExpandedDims(fusedIndexMap.getNumDims(), 1);
  expandedShapeMap.resize(fusedIndexMap.getNumDims());
  for (auto resultExpr : llvm::enumerate(fusedIndexMap.getResults())) {
    unsigned pos = resultExpr.value().cast<AffineDimExpr>().getPosition();
    AffineMap foldedDims = reassociationMaps[resultExpr.index()];
    numExpandedDims[pos] = foldedDims.getNumResults();
    ArrayRef<int64_t> shape =
        expandedShape.slice(foldedDims.getDimPosition(0), numExpandedDims[pos]);
    expandedShapeMap[pos].assign(shape.begin(), shape.end());
  }
  // The remaining dimensions remain the same.
  for (unsigned i : llvm::seq<unsigned>(0, fusedIndexMap.getNumDims()))
    if (expandedShapeMap[i].empty())
      expandedShapeMap[i] = {(*originalLoopRange)[i]};

  // Compute reassociation map from the original op to the expanded op.
  unsigned sum = 0;
  reassociation.reserve(fusedIndexMap.getNumDims());
  for (auto numFoldedDim : llvm::enumerate(numExpandedDims)) {
    auto seq = llvm::seq<int64_t>(sum, sum + numFoldedDim.value());
    reassociation.emplace_back(seq.begin(), seq.end());
    sum += numFoldedDim.value();
  }
  expandedOpNumDims = sum;
  return success();
}

/// Epanding the body of a linalg operation requires adaptations of the accessed
/// loop indices. Specifically, access of indices in the original operation need
/// to be replaced with linearizations of indices in the expanded op. That
/// requires the shape of the expanded dimensions to be static (at least all but
/// the most significant). For now check that these are all statically sized.
/// Note that this could be extended to handle dynamic case, but the
/// implementation below uses `affine.apply` which seems to have issues when the
/// shapes are not static.
LogicalResult isIndexedOpExpandable(LinalgOp linalgOp,
                                    const ExpansionInfo &expansionInfo) {
  for (unsigned i : llvm::seq<unsigned>(0, expansionInfo.getOrigOpNumDims())) {
    ArrayRef<int64_t> expandedShape = expansionInfo.getExpandedShapeOfDim(i);
    if (expandedShape.size() == 1)
      continue;
    for (int64_t shape : expandedShape.drop_front()) {
      if (ShapedType::isDynamic(shape)) {
        return linalgOp.emitError(
            ""unable to fuse indexed generic op where the expanded dim is ""
            ""dynamic"");
      }
    }
  }
  return success();
}

/// Return the indexing map to use in the expanded op for a given the
/// `indexingMap` of the original operation.
static AffineMap
getIndexingMapInExpandedOp(OpBuilder &builder, AffineMap indexingMap,
                           const ExpansionInfo &expansionInfo) {
  SmallVector<AffineExpr, 4> newExprs;
  for (AffineExpr expr : indexingMap.getResults()) {
    unsigned pos = expr.cast<AffineDimExpr>().getPosition();
    SmallVector<AffineExpr, 4> expandedExprs = llvm::to_vector<4>(
        llvm::map_range(expansionInfo.getExpandedDims(pos), [&](int64_t v) {
          return builder.getAffineDimExpr(static_cast<unsigned>(v));
        }));
    newExprs.append(expandedExprs.begin(), expandedExprs.end());
  }
  return AffineMap::get(expansionInfo.getExpandedOpNumDims(),
                        indexingMap.getNumSymbols(), newExprs,
                        builder.getContext());
}

/// Return the type of the operand/result to use in the expanded op given the
/// type in the original op.
static RankedTensorType getExpandedType(RankedTensorType originalType,
                                        AffineMap indexingMap,
                                        const ExpansionInfo &expansionInfo) {
  SmallVector<int64_t, 4> expandedShape;
  for (AffineExpr expr : indexingMap.getResults()) {
    unsigned dim = expr.cast<AffineDimExpr>().getPosition();
    auto dimExpansion = expansionInfo.getExpandedShapeOfDim(dim);
    expandedShape.append(dimExpansion.begin(), dimExpansion.end());
  }
  return RankedTensorType::get(expandedShape, originalType.getElementType());
}

/// Returns the reassociation maps to use in the `linalg.tensor_reshape`
/// operation to convert the operands of the origial operation to operands of
/// the expanded operation. The same method is used to compute the
/// `linalg.tensor_reshape` used to collapse the result of the expanded op to
/// get the value that can replace all uses of the results of the original op.
static SmallVector<ReassociationIndices, 4>
getReassociationForExpansion(AffineMap indexingMap,
                             const ExpansionInfo &expansionInfo) {
  SmallVector<ReassociationIndices, 4> reassociation;
  unsigned numReshapeDims = 0;
  for (AffineExpr expr : indexingMap.getResults()) {
    unsigned dim = expr.cast<AffineDimExpr>().getPosition();
    auto numExpandedDims = expansionInfo.getExpandedDims(dim).size();
    auto indices = llvm::to_vector<2>(
        llvm::seq<int64_t>(numReshapeDims, numReshapeDims + numExpandedDims));
    reassociation.emplace_back(std::move(indices));
    numReshapeDims += numExpandedDims;
  }
  return reassociation;
}

/// Build the body of the expanded IndexedGenericOp. The arguments for the
/// induction variables of the original operation need to be recovered by
/// linearizing the arguments of the corresponding dimensions of the expanded
/// op. For now it is assumed that the shapes of the expanded op needed for
/// linearization are static.
static void buildExpandedIndexedGenericOpRegion(
    PatternRewriter &rewriter, Location loc, Region &originalOpRegion,
    Region &fusedOpRegion, const ExpansionInfo &expansionInfo) {
  assert(fusedOpRegion.empty() && ""expected fused op to have empty region"");
  // Create an entry block in the fused region with same number of arguments
  // as the fused op
  Block *fusedEntryBlock = new Block;
  fusedOpRegion.push_back(fusedEntryBlock);
  rewriter.cloneRegionBefore(originalOpRegion, fusedOpRegion,
                             fusedOpRegion.end());

  // Merge the entry block of the fused op with the cloned blocks. For this
  // compute the value for arguments of the region in the original operation
  // in terms of the arguments of the fused op. Since the original operation
  // is expanded, the expanded dimensions need to be folded back to get the
  // replacement value for the arguments corresponding to interation index.
  // For now this expects that all the loop ranges are constants, which is
  // true if the shapes are all static. This has already been checked in the
  // precondition.
  using namespace edsc::op;
  using namespace edsc::intrinsics;
  OpBuilder::InsertionGuard guard(rewriter);
  SmallVector<Value, 4> argReplacements(originalOpRegion.getNumArguments());
  rewriter.setInsertionPointToStart(fusedEntryBlock);
  edsc::ScopedContext scopedContext(rewriter, loc);
  IndexType indexType = rewriter.getIndexType();
  for (auto i : llvm::seq<unsigned>(0, expansionInfo.getOrigOpNumDims())) {
    Value linearizedIndex = fusedEntryBlock->addArgument(indexType);
    ArrayRef<int64_t> expandedDimsShape =
        expansionInfo.getExpandedShapeOfDim(i).drop_front();
    for (unsigned shape : expandedDimsShape) {
      assert(!ShapedType::isDynamic(shape));
      linearizedIndex = linearizedIndex * std_constant_index(shape);
      linearizedIndex =
          linearizedIndex + fusedEntryBlock->addArgument(indexType);
    }
    argReplacements[i] = linearizedIndex;
  }
  for (auto i : llvm::seq<unsigned>(expansionInfo.getOrigOpNumDims(),
                                    argReplacements.size())) {
    argReplacements[i] =
        fusedEntryBlock->addArgument(originalOpRegion.getArgument(i).getType());
  }
  rewriter.mergeBlocks(fusedEntryBlock->getNextNode(), fusedEntryBlock,
                       argReplacements);
}

/// Update the body of an expanded linalg operation having index semantics. The
/// indices of the original operation need to be recovered by linearizing the
/// indices of the correspoding dimensions of the expanded operation. For now it
/// is assumed that the shapes of the expanded operation needed for
/// linearization are static.
static void updateExpandedIndexOpRegion(PatternRewriter &rewriter, Location loc,
                                        Region &fusedRegion,
                                        const ExpansionInfo &expansionInfo) {
  // Replace the original indices by the linearization of the expanded indices.
  for (IndexOp indexOp :
       llvm::make_early_inc_range(fusedRegion.front().getOps<IndexOp>())) {
    ArrayRef<int64_t> expandedDims =
        expansionInfo.getExpandedDims(indexOp.dim());
    assert(!expandedDims.empty() && ""expected valid expansion info"");

    // Skip index operations that are not affected by the expansion.
    if (expandedDims.size() == 1 &&
        expandedDims.front() == (int64_t)indexOp.dim())
      continue;

    // Linearize the expanded indices of the original index dimension.
    OpBuilder::InsertionGuard guard(rewriter);
    rewriter.setInsertionPointAfter(indexOp);
    ArrayRef<int64_t> expandedDimsShape =
        expansionInfo.getExpandedShapeOfDim(indexOp.dim()).drop_front();
    SmallVector<Value> expandedIndices;
    expandedIndices.reserve(expandedDims.size() - 1);
    llvm::transform(
        expandedDims.drop_front(), std::back_inserter(expandedIndices),
        [&](int64_t dim) { return rewriter.create<IndexOp>(loc, dim); });
    Value newIndex = rewriter.create<IndexOp>(loc, expandedDims.front());
    for (auto it : llvm::zip(expandedDimsShape, expandedIndices)) {
      assert(!ShapedType::isDynamic(std::get<0>(it)));
      AffineExpr idx, acc;
      bindDims(rewriter.getContext(), idx, acc);
      newIndex = rewriter.create<AffineApplyOp>(
          indexOp.getLoc(), idx + acc * std::get<0>(it),
          ValueRange{std::get<1>(it), newIndex});
    }
    rewriter.replaceOp(indexOp, newIndex);
  }
}

/// Implements the fusion of a tensor_reshape op and a generic/indexed_generic
/// op as explained in `isFusableWithReshapeByExpansion`. Assumes that those
/// conditions have been satisfied.
static Optional<SmallVector<Value, 1>>
fuseWithReshapeByExpansion(LinalgOp linalgOp, TensorReshapeOp reshapeOp,
                           unsigned fusedTensorIndex,
                           PatternRewriter &rewriter) {
  assert(isFusableWithReshapeByDimExpansion(linalgOp, fusedTensorIndex) &&
         ""preconditions for fuse operation failed"");
  // Check if reshape is expanding or collapsing.
  bool isExpanding =
      reshapeOp.getSrcType().getRank() < reshapeOp.getResultType().getRank();
  RankedTensorType expandedType =
      isExpanding ? reshapeOp.getResultType() : reshapeOp.getSrcType();
  bool hasIndexSemantics = linalgOp.hasIndexSemantics() ||
                           isa<IndexedGenericOp>(linalgOp.getOperation());

  ExpansionInfo expansionInfo;
  if (failed(expansionInfo.compute(linalgOp, fusedTensorIndex,
                                   reshapeOp.getReassociationMaps(),
                                   expandedType.getShape())))
    return llvm::None;

  if (hasIndexSemantics &&
      failed(isIndexedOpExpandable(linalgOp, expansionInfo)))
    return llvm::None;

  SmallVector<AffineMap, 4> expandedOpIndexingMaps = llvm::to_vector<4>(
      llvm::map_range(linalgOp.getIndexingMaps(), [&](AffineMap m) {
        return getIndexingMapInExpandedOp(rewriter, m, expansionInfo);
      }));

  SmallVector<Value, 4> expandedOpOperands;
  for (auto operand : llvm::enumerate(linalgOp.getInputs())) {
    if (operand.index() == fusedTensorIndex) {
      expandedOpOperands.push_back(reshapeOp.src());
      continue;
    }
    AffineMap indexingMap = linalgOp.getInputIndexingMap(operand.index());
    RankedTensorType expandedOperandType =
        getExpandedType(operand.value().getType().cast<RankedTensorType>(),
                        indexingMap, expansionInfo);
    if (expandedOperandType != operand.value().getType()) {
      // Reshape the operand to get the right type.
      SmallVector<ReassociationIndices, 4> reassociation =
          getReassociationForExpansion(indexingMap, expansionInfo);
      expandedOpOperands.push_back(rewriter.create<TensorReshapeOp>(
          linalgOp.getLoc(), expandedOperandType, operand.value(),
          reassociation));
      continue;
    }
    expandedOpOperands.push_back(operand.value());
  }

  Location loc = linalgOp.getLoc();
  SmallVector<Value, 1> outputs;
  for (auto result : llvm::enumerate(linalgOp.getOutputs())) {
    AffineMap indexingMap = linalgOp.getOutputIndexingMap(result.index());
    RankedTensorType expandedOutputType =
        getExpandedType(result.value().getType().cast<RankedTensorType>(),
                        indexingMap, expansionInfo);
    if (expandedOutputType != result.value().getType()) {
      SmallVector<ReassociationIndices, 4> reassociation =
          getReassociationForExpansion(indexingMap, expansionInfo);
      outputs.push_back(rewriter.create<TensorReshapeOp>(
          linalgOp.getLoc(), expandedOutputType, result.value(),
          reassociation));
    }
  }

  // The iterator types of the expanded op are all parallel.
  SmallVector<StringRef, 4> iteratorTypes(expansionInfo.getExpandedOpNumDims(),
                                          getParallelIteratorTypeName());

  TypeRange resultTypes = ValueRange(outputs).getTypes();
  LinalgOp fusedOp = createLinalgOpOfSameType(
      linalgOp, rewriter, linalgOp.getLoc(), resultTypes,
      /*inputs=*/expandedOpOperands, outputs, expandedOpIndexingMaps,
      iteratorTypes);
  Region &fusedRegion = fusedOp->getRegion(0);
  Region &originalRegion = linalgOp->getRegion(0);

  if (isa<GenericOp>(linalgOp.getOperation())) {
    rewriter.cloneRegionBefore(originalRegion, fusedRegion,
                               fusedRegion.begin());
  } else {
    assert(isa<IndexedGenericOp>(linalgOp.getOperation()));
    buildExpandedIndexedGenericOpRegion(rewriter, loc, originalRegion,
                                        fusedRegion, expansionInfo);
  }

  // Update the index accesses after the expansion.
  if (linalgOp.hasIndexSemantics())
    updateExpandedIndexOpRegion(rewriter, loc, fusedRegion, expansionInfo);

  // Reshape the result values to their original shape if this is a collapsing
  // reshape folded into its consumer.
  SmallVector<Value, 1> resultVals;
  for (auto result : llvm::enumerate(linalgOp->getResults())) {
    if (!isExpanding &&
        resultTypes[result.index()] != result.value().getType()) {
      SmallVector<ReassociationIndices, 4> reassociation =
          getReassociationForExpansion(
              linalgOp.getOutputIndexingMap(result.index()), expansionInfo);
      resultVals.push_back(rewriter.create<TensorReshapeOp>(
          linalgOp.getLoc(), result.value().getType(),
          fusedOp->getResult(result.index()), reassociation));
    } else {
      resultVals.push_back(fusedOp->getResult(result.index()));
    }
  }
  // Assuming a single result.
  return resultVals;
}

namespace {

/// Pattern to fold tensor_reshape op with its consumer by using the source of
/// the reshape op as the operand in the consumer (instead of the result of the
/// tensor_reshapeop) when the tensor_reshape op is collapsing. The
/// corresponding index map in the consumer needs to be modified to linearize
/// the folded dimension.
///
/// For example,
///
/// #map0 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
/// %0 = linalg.tensor_reshape %arg0
///        [affine_map<(i, j, k, l) -> (i)>, affine_map<(i, j, k, l) -> (j, k)>,
///         affine_map<(i, j, k, l) -> (l)>]
///      tensor<?x?x?xf32> into tensor<?x?x4x?xf32>
/// %1 = linalg.generic { indexing_maps = [#map0, #map0, #map0], ... }
///        ins(%0, %arg1 : tensor<?x?x4x?xf32>, tensor<?x?x4x?xf32>) ...
///        -> tensor<?x?x4x?xf32>
///
/// can be folded into
///
/// #map0 = affine_map<(d0, d1, d2, d3) -> (d0, d1 * 4 + d2, d3)>
/// #map1 = affine_map<(d0, d1, d2, d3) -> (d0, d1, d2, d3)>
/// %0 = linalg.generic { indexing_maps = [#map0, #map1, #map1] ... }
///        ins(%arg0, %arg1 : tensor<?x?x?xf32>, tensor<?x?x4x?xf32>) ...
///        -> tensor<?x?x4x?xf32>
template <typename LinalgOpTy, bool foldUnitDimReshapesOnly>
struct FoldProducerReshapeOpByLinearization
    : public OpRewritePattern<LinalgOpTy> {
  using OpRewritePattern<LinalgOpTy>::OpRewritePattern;

  LogicalResult matchAndRewrite(LinalgOpTy op,
                                PatternRewriter &rewriter) const override {
    if (!op.hasTensorSemantics())
      return failure();
    LinalgOp linalgOp = cast<LinalgOp>(op.getOperation());
    for (auto operand : llvm::enumerate(linalgOp.getInputs())) {
      TensorReshapeOp reshapeOp =
          operand.value().getDefiningOp<TensorReshapeOp>();
      if (!reshapeOp ||
          !isTensorReshapeOpFoldableByLinearization(
              reshapeOp, linalgOp.getInputIndexingMap(operand.index()),
              /*asProducer =*/true) ||
          (foldUnitDimReshapesOnly &&
           !isUnitDimExpansionOnly(reshapeOp.getResultType().getShape(),
                                   reshapeOp.getReassociationMaps())))
        continue;

      // Compute the fused operands list,
      SmallVector<Value, 2> fusedOperands(linalgOp.getInputs());
      fusedOperands[operand.index()] = reshapeOp.src();
      fusedOperands.append(linalgOp.getOutputs().begin(),
                           linalgOp.getOutputs().end());

      // Compute indexing_maps for the fused operation. The indexing_maps for
      // the operands of the consumers that arent fused are the same.
      SmallVector<AffineMap, 4> fusedIndexMaps = llvm::to_vector<4>(
          op.indexing_maps().template getAsValueRange<AffineMapAttr>());

      // Accepted consumer maps are either identity or permutation.
      auto invMap = inversePermutation(fusedIndexMaps[operand.index()]);

      // Compute the indexing map to use for the result of the producer.
      AffineMap modifiedMap =
          linearizeCollapsedDims(invMap, reshapeOp.getResultType().getShape(),
                                 reshapeOp.getReassociationMaps());
      for (AffineExpr expr : modifiedMap.getResults()) {
        if (!expr.isPureAffine())
          return failure();
      }
      fusedIndexMaps[operand.index()] = modifiedMap;

      // Further check that the resulting index maps can be fused and
      // inverted. Without this the resultant op is not legal.
      if (!inversePermutation(concatAffineMaps(fusedIndexMaps))) {
        return rewriter.notifyMatchFailure(
            op, ""fused op loop bound computation failed"");
      }

      rewriter.startRootUpdate(op);
      op->setOperands(fusedOperands);
      op.indexing_mapsAttr(rewriter.getAffineMapArrayAttr(fusedIndexMaps));
      rewriter.finalizeRootUpdate(op);
      return success();
    }
    return failure();
  }
};

static SmallVector<ReassociationIndices>
getReassociationIndices(ArrayRef<AffineMap> maps) {
  SmallVector<ReassociationIndices> reassociation;
  for (AffineMap map : maps) {
    ReassociationIndices indices;
    for (unsigned i = 0, e = map.getNumResults(); i < e; i++) {
      unsigned pos = map.getResult(i).cast<AffineDimExpr>().getPosition();
      indices.push_back(pos);
    }
    reassociation.push_back(indices);
  }
  return reassociation;
}

/// Pattern to move rank reducing reshape after an elementwise linalg generic
/// op. This is useful to expose more fusion opportunities between named ops and
/// generic op. This can only be done if there is no broadcast or permuation
/// within the dimensions we need to merge.
///
/// For example,
///
///  %0 = linalg.tensor_reshape %A [
///    affine_map<(d0, d1, d2) -> (d0, d1)>, affine_map<(d0, d1, d2) -> (d2)>]
///      : tensor<12544x16xf32> into tensor<112x112x16xf32>
///  %2 = linalg.generic {indexing_maps = [
///    affine_map<(d0, d1, d2) -> (d0, d1, d2)>,
///    affine_map<(d0, d1, d2) -> (d2)>,
///    affine_map<(d0, d1, d2) -> (d0, d1, d2)>], iterator_types =
///    [""parallel"", ""parallel"", ""parallel""]} {
///  } -> tensor<112x112x16xf32>
///
///  into
///
///  %2 = linalg.generic {indexing_maps = [
///    affine_map<(d0, d1) -> (d0, d1)>,
///    affine_map<(d0, d1) -> (d1)>,
///    affine_map<(d0, d1) -> (d0, d1)>],
///    iterator_types = [""parallel"", ""parallel""]} ins(%arg0, %arg1
///    : tensor<12544x16xf32>, tensor<16xf32>) outs(%1 : tensor<12544x16xf32>) {
///  } -> tensor<12544x16xf32>
///  %3 = linalg.tensor_reshape %2 [
///    #affine_map<(d0, d1, d2) -> (d0, d1)>, affine_map<(d0, d1, d2) -> (d2)>]
///    : tensor<12544x16xf32> into tensor<112x112x16xf32>
template <typename GenericOpTy>
struct PushExpandingReshape : public OpRewritePattern<GenericOpTy> {
  using OpRewritePattern<GenericOpTy>::OpRewritePattern;

  LogicalResult matchAndRewrite(GenericOpTy op,
                                PatternRewriter &rewriter) const override {
    // Only apply to elementwise linalg on tensor.
    if (!op.hasTensorSemantics() ||
        op.getNumParallelLoops() != op.getNumLoops())
      return failure();
    // Only support identity output maps. It could be extended to permuations if
    // needed.
    if (llvm::any_of(op.getOutputIndexingMaps(),
                     [](AffineMap map) { return !map.isIdentity(); }))
      return failure();
    int64_t destRank = op.getNumParallelLoops();
    SmallVector<Value, 4> newOperands = llvm::to_vector<4>(op.getInputs());
    TensorReshapeOp reshapeFound;
    // 1. Look for tensor_reshape operands and figure out save the dimensions
    // merged.
    for (auto operand : llvm::enumerate(op.getInputs())) {
      TensorReshapeOp reshapeOp =
          operand.value().template getDefiningOp<TensorReshapeOp>();
      if (!reshapeOp || reshapeOp.getSrcType().getRank() >
                            reshapeOp.getResultType().getRank()) {
        continue;
      }
      // TODO: We could support non-identity map as long as the merged
      // dimensions are still contiguous.
      if (!op.getIndexingMaps()[operand.index()].isIdentity())
        continue;
      if (reshapeFound) {
        // Only support a second reshape op if it has the same reassociate maps.
        if (reshapeFound.getReassociationMaps() ==
            reshapeOp.getReassociationMaps())
          newOperands[operand.index()] = reshapeOp.src();
        continue;
      }
      reshapeFound = reshapeOp;
      newOperands[operand.index()] = reshapeOp.src();
    }
    if (!reshapeFound)
      return failure();

    // Calculate the reassociation indices and rassociated reverse map.
    SmallVector<ReassociationIndices> reassociation =
        getReassociationIndices(reshapeFound.getReassociationMaps());
    SmallVector<unsigned, 4> remap(destRank);
    for (auto &indices : llvm::enumerate(reassociation)) {
      for (int64_t index : indices.value()) {
        remap[index] = indices.index();
      }
    }
    // 2. Verify that we can merge the dimensions in the linalg and that we
    // don't need to create new reshapes operands. Inserting new reshape
    // operands would defeat the purpose of the transformation.
    for (auto operand : llvm::enumerate(op.getInputs())) {
      if (operand.value() == newOperands[operand.index()]) {
        AffineMap map = op.getIndexingMaps()[operand.index()];
        for (unsigned i : llvm::seq(unsigned(0), map.getNumResults())) {
          if (reassociation[remap[map.getDimPosition(i)]].size() > 1)
            return failure();
        }
      }
    }

    // 3. Calculate the affine map remapping and the reassociation to apply to
    // output tensors.
    SmallVector<AffineMap, 4> newMaps;
    unsigned newRank = reassociation.size();
    for (auto map : op.getIndexingMaps()) {
      SmallVector<AffineExpr> newExprs;
      for (auto expr : map.getResults()) {
        unsigned position = expr.template cast<AffineDimExpr>().getPosition();
        // Skip dimension merged except for the last of the group.
        if (reassociation[remap[position]].back() == position) {
          newExprs.push_back(
              getAffineDimExpr(remap[position], op.getContext()));
        }
      }
      newMaps.push_back(AffineMap::get(newRank, 0, newExprs, op.getContext()));
    }

    // 4. Reshape the output tensors.
    SmallVector<Value> newOutputs;
    SmallVector<Type> newOutputTypes;
    for (auto output : op.outputs()) {
      Value newOutput = rewriter.create<TensorReshapeOp>(
          op->getLoc(), reshapeFound.getSrcType(), output, reassociation);
      newOutputTypes.push_back(newOutput.getType());
      newOutputs.push_back(newOutput);
    }
    // 5. Create a new generic op with lowerer rank.
    SmallVector<StringRef, 4> iteratorTypes(newRank,
                                            getParallelIteratorTypeName());
    auto newOp =
        rewriter.create<GenericOpTy>(op->getLoc(), newOutputTypes, newOperands,
                                     newOutputs, newMaps, iteratorTypes);
    rewriter.inlineRegionBefore(op.region(), newOp.region(),
                                newOp.region().begin());
    // 6. Reshape the so that the type matches the uses.
    SmallVector<Value> newResults;
    for (auto result : llvm::enumerate(newOp->getResults())) {
      newResults.push_back(rewriter.create<TensorReshapeOp>(
          op->getLoc(), op.getOutputTensorTypes()[result.index()],
          result.value(), reassociation));
    }
    rewriter.replaceOp(op, newResults);
    return success();
  }
};

/// Pattern to fuse a tensor_reshape op with its consumer
/// generic/indexed_generic op, when the reshape op is collapsing
/// dimensions. The dimensionality of the loop in the consumer is expanded.
template <typename GenericOpTy>
class FoldWithProducerReshapeOpByExpansion
    : public OpRewritePattern<GenericOpTy> {
public:
  FoldWithProducerReshapeOpByExpansion(MLIRContext *context,
                                       bool foldUnitDimReshapes,
                                       PatternBenefit benefit = 1)
      : OpRewritePattern<GenericOpTy>(context, benefit),
        allowFoldingUnitDimReshapes(foldUnitDimReshapes) {}

  LogicalResult matchAndRewrite(GenericOpTy genericOp,
                                PatternRewriter &rewriter) const override {
    LinalgOp linalgOp = cast<LinalgOp>(genericOp.getOperation());
    for (auto operand : llvm::enumerate(linalgOp.getInputs())) {
      TensorReshapeOp reshapeOp =
          operand.value().getDefiningOp<TensorReshapeOp>();
      if (!reshapeOp)
        continue;

      // Fold only if
      // - The tensor reshape op is folding.
      // - All constraints of fusing with reshape by expansion are met.
      if (reshapeOp.getSrcType().getRank() <
              reshapeOp.getResultType().getRank() ||
          !isFusableWithReshapeByDimExpansion(linalgOp, operand.index()) ||
          (!allowFoldingUnitDimReshapes &&
           isUnitDimExpansionOnly(reshapeOp.getSrcType().getShape(),
                                  reshapeOp.getReassociationMaps())))
        continue;

      Optional<SmallVector<Value, 1>> replacementValues =
          fuseWithReshapeByExpansion(linalgOp, reshapeOp, operand.index(),
                                     rewriter);
      if (!replacementValues)
        return failure();
      rewriter.replaceOp(genericOp, replacementValues.getValue());
      return success();
    }
    return failure();
  }

private:
  bool allowFoldingUnitDimReshapes;
};

/// Pattern to fold tensor_reshape op with its producer. The corresponding index
/// map in the consumer needs to be modified to linearize the folded dimension.
template <bool foldUnitDimReshapesOnly>
struct FoldConsumerReshapeOpByLinearization
    : public OpRewritePattern<TensorReshapeOp> {
  using OpRewritePattern<TensorReshapeOp>::OpRewritePattern;

  LogicalResult matchAndRewrite(TensorReshapeOp reshapeOp,
                                PatternRewriter &rewriter) const override {
    LinalgOp producer = reshapeOp.src().getDefiningOp<LinalgOp>();
    if (!producer ||
        !isa<GenericOp, IndexedGenericOp>(producer.getOperation()) ||
        !producer.hasTensorSemantics() || producer.getNumOutputs() != 1 ||
        !isTensorReshapeOpFoldableByLinearization(
            reshapeOp, producer.getOutputIndexingMap(0),
            /*asProducer =*/false) ||
        (foldUnitDimReshapesOnly &&
         !isUnitDimExpansionOnly(reshapeOp.getSrcType().getShape(),
                                 reshapeOp.getReassociationMaps())))
      return failure();
    // The indexing_maps for the operands of the fused operation are same as
    // those for the operands of the producer.
    SmallVector<AffineMap, 4> fusedIndexMaps = llvm::to_vector<4>(
        producer.indexing_maps().getAsValueRange<AffineMapAttr>());

    auto invMap = inversePermutation(producer.getOutputIndexingMap(0));

    // Compute the indexing map to use for the operand of the producer.
    AffineMap modifiedMap =
        linearizeCollapsedDims(invMap, reshapeOp.getSrcType().getShape(),
                               reshapeOp.getReassociationMaps());
    for (AffineExpr expr : modifiedMap.getResults()) {
      if (!expr.isPureAffine()) {
        return rewriter.notifyMatchFailure(
            producer, ""fused op indexing map is not affine"");
      }
    }
    fusedIndexMaps.back() = modifiedMap;

    // Further check that the resulting index maps can be fused and
    // inverted. Without this the resultant op is not legal.
    if (!inversePermutation(concatAffineMaps(fusedIndexMaps))) {
      return rewriter.notifyMatchFailure(
          producer, ""fused op loop bound computation failed"");
    }

    Location loc = producer.getLoc();
    Value output = rewriter.create<TensorReshapeOp>(
        loc, producer.getOutputs()[0], reshapeOp.getReassociationExprs());
    LinalgOp fusedOp = createLinalgOpOfSameType(
        producer, rewriter, loc, reshapeOp.getResultType(),
        /*inputs=*/producer.getInputs(),
        // TODO: handle outputs.
        /*outputs=*/output, rewriter.getAffineMapArrayAttr(fusedIndexMaps),
        producer.iterator_types(),
        /*doc=*/nullptr,
        /*library_call=*/nullptr,
        /*sparse=*/nullptr);
    auto &fusedRegion = fusedOp->getRegion(0);
    rewriter.cloneRegionBefore(producer->getRegion(0), fusedRegion,
                               fusedRegion.begin());
    rewriter.replaceOp(reshapeOp, fusedOp->getResults());
    return success();
  }
};

/// Pattern to fold a tensor_reshape op with its producer generic op if the
/// tensor_reshape op is expanding, by expanding the dimensionality of the loop
/// in the producer op.
struct FoldReshapeWithGenericOpByExpansion
    : public OpRewritePattern<TensorReshapeOp> {
  using OpRewritePattern<TensorReshapeOp>::OpRewritePattern;
  LogicalResult matchAndRewrite(TensorReshapeOp reshapeOp,
                                PatternRewriter &rewriter) const override {
    // Fold only if
    // - The tensor reshape op is a expanding case.
    // - All constraints of fusing with reshape by expansion are met.
    if (reshapeOp.getSrcType().getRank() > reshapeOp.getResultType().getRank())
      return failure();
    LinalgOp producer = reshapeOp.src().getDefiningOp<LinalgOp>();
    if (!producer || producer.getNumOutputs() != 1 ||
        !isFusableWithReshapeByDimExpansion(producer,
                                            producer.getNumInputs()) ||
        isUnitDimExpansionOnly(reshapeOp.getResultType().getShape(),
                               reshapeOp.getReassociationMaps()))
      return failure();
    Optional<SmallVector<Value, 1>> replacementValues =
        fuseWithReshapeByExpansion(producer, reshapeOp, producer.getNumInputs(),
                                   rewriter);
    if (!replacementValues)
      return failure();
    rewriter.replaceOp(reshapeOp, replacementValues.getValue());
    return success();
  }
};

/// Pattern to fold a GenericOp/IndexedGenericOp with a splat constant.
template <typename LinalgOpTy>
class FoldSplatConstants : public OpRewritePattern<LinalgOpTy> {
public:
  FoldSplatConstants(MLIRContext *context, ControlElementwiseOpsFusionFn &fun,
                     PatternBenefit benefit = 1)
      : OpRewritePattern<LinalgOpTy>(context, benefit), controlFn(fun) {}

  LogicalResult matchAndRewrite(LinalgOpTy op,
                                PatternRewriter &rewriter) const override {
    if (!op.hasTensorSemantics())
      return failure();
    LinalgOp linalgOp = cast<LinalgOp>(op.getOperation());
    for (auto operand : llvm::enumerate(linalgOp.getInputOpOperands())) {
      ConstantOp constantOp = operand.value().get().getDefiningOp<ConstantOp>();
      if (!constantOp ||
          !constantOp.value().cast<DenseElementsAttr>().isSplat() ||
          !controlFn(constantOp->getResult(0), operand.value()))
        continue;

      // The indexing_maps for the operands of the fused operation are same as
      // those for the operands of the linalgOp without the indexing map at
      // operand.index()
      SmallVector<AffineMap, 4> fusedIndexMaps = llvm::to_vector<4>(
          linalgOp.indexing_maps().getAsValueRange<AffineMapAttr>());
      fusedIndexMaps.erase(std::next(fusedIndexMaps.begin(), operand.index()));

      // Check if the operation shapes to loops map is computable.
      if (!inversePermutation(concatAffineMaps(fusedIndexMaps))) {
        return rewriter.notifyMatchFailure(
            linalgOp, ""fused op loop bound computation failed"");
      }

      // The operands list is same as the linalgOp with the argument for
      // constant index dropped.
      SmallVector<Value, 4> fusedOperands(linalgOp.getInputs());
      fusedOperands.erase(std::next(fusedOperands.begin(), operand.index()));

      // Create a constant scalar value from the splat constant.
      Value scalarConstant = rewriter.create<ConstantOp>(
          constantOp.getLoc(),
          constantOp.value().cast<DenseElementsAttr>().getSplatValue());

      LinalgOp fusedOp = createLinalgOpOfSameType(
          linalgOp, rewriter, rewriter.getUnknownLoc(),
          linalgOp->getResultTypes(),
          /*inputs=*/fusedOperands,
          /*outputs=*/linalgOp.getOutputs(),
          rewriter.getAffineMapArrayAttr(fusedIndexMaps),
          linalgOp.iterator_types(),
          /*doc=*/nullptr,
          /*library_call=*/nullptr,
          /*sparse=*/nullptr);

      // Map the block argument corresponding to the replaced argument with the
      // scalar constant.
      Region &linalgOpRegion = linalgOp->getRegion(0);
      Block &entryBlock = *linalgOpRegion.begin();
      unsigned argIndex = entryBlock.getNumArguments() -
                          linalgOp.getNumShapedOperands() + operand.index();
      BlockAndValueMapping mapping;
      mapping.map(entryBlock.getArgument(argIndex), scalarConstant);
      Region &fusedRegion = fusedOp->getRegion(0);
      rewriter.cloneRegionBefore(linalgOpRegion, fusedRegion,
                                 fusedRegion.begin(), mapping);
      rewriter.replaceOp(linalgOp, fusedOp->getResults());
      return success();
    }
    return failure();
  }

private:
  ControlElementwiseOpsFusionFn controlFn;
};
} // namespace

static Optional<SmallVector<Value, 1>>
fuseElementwiseOps(PatternRewriter &rewriter, OpOperand &consumerOpOperand,
                   const ControlElementwiseOpsFusionFn &controlFn) {
  Operation *producer = consumerOpOperand.get().getDefiningOp();
  if (!producer || producer->getNumResults() != 1)
    return llvm::None;

  // Fuse when consumer is GenericOp or IndexedGenericOp.
  if (!isa<GenericOp, IndexedGenericOp>(consumerOpOperand.getOwner()) ||
      !isa<GenericOp, IndexedGenericOp>(producer))
    return llvm::None;

  return fuseElementwiseOpsImpl(cast<LinalgOp>(producer), consumerOpOperand,
                                controlFn, rewriter);
}

namespace {
/// Patterns to fuse a generic op, with the producer of its operands.
template <typename LinalgOpTy>
class FuseElementwiseOps : public OpRewritePattern<LinalgOpTy> {
public:
  FuseElementwiseOps(MLIRContext *context, ControlElementwiseOpsFusionFn &fun,
                     PatternBenefit benefit = 1)
      : OpRewritePattern<LinalgOpTy>(context, benefit), controlFn(fun) {}

  LogicalResult matchAndRewrite(LinalgOpTy op,
                                PatternRewriter &rewriter) const override {
    // Find the first operand that is defined by another generic op on tensors.
    for (OpOperand &opOperand : op.getShapedOpOperands()) {
      LinalgOp producerOp =
          dyn_cast_or_null<LinalgOp>(opOperand.get().getDefiningOp());
      if (!producerOp || !producerOp.hasTensorSemantics())
        continue;
      Optional<SmallVector<Value, 1>> fusedOpResults =
          fuseElementwiseOps(rewriter, opOperand, controlFn);
      if (fusedOpResults) {
        rewriter.replaceOp(op, *fusedOpResults);
        return success();
      }
    }
    return failure();
  }

private:
  ControlElementwiseOpsFusionFn controlFn;
};

/// Pass that fuses generic ops on tensors. Used only for testing.
struct FusionOfTensorOpsPass
    : public LinalgFusionOfTensorOpsBase<FusionOfTensorOpsPass> {
  void runOnOperation() override {
    Operation *op = getOperation();
    RewritePatternSet patterns(op->getContext());
    populateElementwiseOpsFusionPatterns(
        patterns,
        LinalgElementwiseFusionOptions().setAllowFoldingUnitDimReshapes(
            allowFoldingUnitDimReshapes));
    (void)applyPatternsAndFoldGreedily(op->getRegions(), std::move(patterns));
  }
};

/// Pass to test folding of reshape op with generic/indexed_generic ops by
/// linearization.
struct FoldReshapeOpsByLinearizationPass
    : public LinalgFoldReshapeOpsByLinearizationBase<
          FoldReshapeOpsByLinearizationPass> {
  void runOnOperation() override {
    Operation *op = getOperation();
    RewritePatternSet patterns(op->getContext());
    populateFoldReshapeOpsByLinearizationPatterns(patterns);
    (void)applyPatternsAndFoldGreedily(op->getRegions(), std::move(patterns));
  }
};

} // namespace

void mlir::linalg::populateFoldReshapeOpsByLinearizationPatterns(
    RewritePatternSet &patterns) {
  patterns.add<FoldProducerReshapeOpByLinearization<GenericOp, false>,
               FoldProducerReshapeOpByLinearization<IndexedGenericOp, false>,
               FoldConsumerReshapeOpByLinearization<false>>(
      patterns.getContext());
}

void mlir::linalg::populateFoldUnitDimsReshapeOpsByLinearizationPatterns(
    RewritePatternSet &patterns) {
  patterns.add<FoldProducerReshapeOpByLinearization<GenericOp, true>,
               FoldProducerReshapeOpByLinearization<IndexedGenericOp, true>,
               FoldConsumerReshapeOpByLinearization<true>>(
      patterns.getContext());
}

void mlir::linalg::populateFoldReshapeOpsByExpansionPatterns(
    RewritePatternSet &patterns, bool allowFoldingUnitDimReshapes) {
  patterns.add<FoldReshapeWithGenericOpByExpansion>(patterns.getContext());
  patterns.add<FoldWithProducerReshapeOpByExpansion<GenericOp>,
               FoldWithProducerReshapeOpByExpansion<IndexedGenericOp>>(
      patterns.getContext(), allowFoldingUnitDimReshapes);
}

void mlir::linalg::populateElementwiseOpsFusionPatterns(
    RewritePatternSet &patterns, LinalgElementwiseFusionOptions options) {
  auto *context = patterns.getContext();
  patterns
      .add<FuseElementwiseOps<GenericOp>, FuseElementwiseOps<IndexedGenericOp>,
           FoldSplatConstants<GenericOp>, FoldSplatConstants<IndexedGenericOp>>(
          context, options.controlElementwiseOpsFusionFn);
  populateFoldReshapeOpsByExpansionPatterns(
      patterns, options.allowFoldingUnitDimReshapes);
  AffineApplyOp::getCanonicalizationPatterns(patterns, context);
  GenericOp::getCanonicalizationPatterns(patterns, context);
  IndexedGenericOp::getCanonicalizationPatterns(patterns, context);
  TensorReshapeOp::getCanonicalizationPatterns(patterns, context);
}

void mlir::linalg::populatePushReshapeOpsPatterns(RewritePatternSet &patterns) {
  auto *context = patterns.getContext();
  patterns.add<PushExpandingReshape<GenericOp>,
               PushExpandingReshape<IndexedGenericOp>>(context);
}

std::unique_ptr<Pass> mlir::createLinalgFusionOfTensorOpsPass() {
  return std::make_unique<FusionOfTensorOpsPass>();
}

std::unique_ptr<Pass> mlir::createFoldReshapeOpsByLinearizationPass() {
  return std::make_unique<FoldReshapeOpsByLinearizationPass>();
}
",16354,True,2926.79058979444,median